@abderraouf-yt/got-mcp 3.2.0 → 3.2.1

package/dist/context/ContextStore.js

@@ -0,0 +1,89 @@
+/**
+ * Shared Context Store (CA-MCP pattern, arXiv 2601.11595)
+ * Key-value store for intermediate reasoning state.
+ * Tracks provenance (source) for trust scoring.
+ *
+ * @module context/ContextStore
+ */
+/**
+ * In-memory shared context store.
+ * Enables cross-tool knowledge sharing within a session,
+ * reducing redundant LLM calls (CA-MCP, 2026).
+ */
+export class ContextStore {
+    store = new Map();
+    /**
+     * Set a key-value pair with source provenance.
+     */
+    set(key, value, source) {
+        this.store.set(key, {
+            value,
+            source,
+            updatedAt: new Date().toISOString(),
+        });
+    }
+    /**
+     * Get a value by key. Returns undefined if not found.
+     */
+    get(key) {
+        return this.store.get(key)?.value;
+    }
+    /**
+     * Get value with full provenance metadata.
+     */
+    getWithProvenance(key) {
+        return this.store.get(key);
+    }
+    /**
+     * Check if a key exists.
+     */
+    has(key) {
+        return this.store.has(key);
+    }
+    /**
+     * Delete a key.
+     */
+    delete(key) {
+        return this.store.delete(key);
+    }
+    /**
+     * List all keys with their sources (no values — lightweight).
+     */
+    list() {
+        return Array.from(this.store.entries()).map(([key, entry]) => ({
+            key,
+            source: entry.source,
+            updatedAt: entry.updatedAt,
+        }));
+    }
+    /**
+     * Get full store as a serializable object.
+     */
+    getAll() {
+        const result = {};
+        for (const [key, entry] of this.store) {
+            result[key] = entry;
+        }
+        return result;
+    }
+    /**
+     * Clear all context.
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Number of entries in the store.
+     */
+    get size() {
+        return this.store.size;
+    }
+}
+// Singleton context store instance
+let contextInstance = null;
+export function getContextInstance() {
+    if (!contextInstance) {
+        contextInstance = new ContextStore();
+    }
+    return contextInstance;
+}

package/dist/context/index.js

@@ -0,0 +1,4 @@
+/**
+ * Context module barrel export.
+ */
+export { ContextStore, getContextInstance } from "./ContextStore.js";

package/dist/graph/ThoughtGraph.js

@@ -673,6 +673,129 @@ export class ThoughtGraph {
             release();
         }
     }
+    // ==========================================
+    // v4.0: Self-Reflection + Multi-Dimensional Scoring
+    // ==========================================
+    /**
+     * Compute a composite score from a ConfidenceVector.
+     * Weights: logical (35%), factual (30%), relevance (25%), novelty (10%).
+     */
+    computeCompositeScore(confidence) {
+        const score = (confidence.factual * 0.30 +
+            confidence.logical * 0.35 +
+            confidence.relevance * 0.25 +
+            confidence.novelty * 0.10);
+        return Math.round(score * 100) / 100;
+    }
+    /**
+     * Self-reflection loop (2026 pattern).
+     * Creates a critique node linked via "reflection" edge.
+     * If a refined thought is provided, also creates a branch.
+     *
+     * @param nodeId - Node to reflect on
+     * @param critique - The critique text
+     * @param confidence - Multi-dimensional confidence assessment
+     * @param refinedThought - Optional improved version of the thought
+     * @returns IDs of created nodes
+     */
+    reflectAndRefine(nodeId, critique, confidence, refinedThought) {
+        const node = this.nodes.get(nodeId);
+        if (!node) {
+            throw new ThoughtGraphNotFoundError(nodeId);
+        }
+        const compositeScore = this.computeCompositeScore(confidence);
+        // Update the original node with confidence data
+        this.nodes.set(nodeId, {
+            ...node,
+            score: compositeScore,
+            confidence,
+            updatedAt: new Date().toISOString(),
+        });
+        // Create critique node
+        const critiqueId = this.addNode(`[Reflection] ${critique}`);
+        this.addEdge(nodeId, critiqueId, "reflection");
+        // Update critique node with assessment metadata
+        const critiqueNode = this.nodes.get(critiqueId);
+        this.nodes.set(critiqueId, {
+            ...critiqueNode,
+            score: compositeScore,
+            confidence,
+            status: compositeScore >= 0.7 ? "validated" : "active",
+            metadata: {
+                ...(critiqueNode.metadata ?? {}),
+                reflectionOf: nodeId,
+                assessmentType: "self-reflection",
+            },
+        });
+        let branchId;
+        // If critique reveals a flaw and refined version provided, branch
+        if (refinedThought && compositeScore < 0.7) {
+            branchId = this.addNode(refinedThought);
+            this.addEdge(nodeId, branchId, "branch");
+            const branchNode = this.nodes.get(branchId);
+            this.nodes.set(branchId, {
+                ...branchNode,
+                status: "active",
+                metadata: {
+                    ...(branchNode.metadata ?? {}),
+                    refinedFrom: nodeId,
+                    refinementReason: critique,
+                },
+            });
+        }
+        this.stateVersion++;
+        this.save();
+        return { critiqueId, branchId, compositeScore };
+    }
+    /**
+     * Export the winning path as a structured reasoning trace.
+     * Format compatible with Long CoT used by DeepSeek-R1 and o3.
+     */
+    exportReasoningTrace() {
+        const result = this.findWinningPath({ beamWidth: 1 });
+        if (result.path.length === 0) {
+            return {
+                question: "",
+                steps: [],
+                conclusion: "",
+                compositeScore: 0,
+                totalNodes: this.nodes.size,
+                totalEdges: this.edges.length,
+                exportedAt: new Date().toISOString(),
+            };
+        }
+        const steps = result.path.map((node, index) => {
+            // Find reflection children
+            const reflections = this.edges
+                .filter(e => e.from === node.id && e.relation === "reflection")
+                .map(e => this.nodes.get(e.to)?.thought ?? "")
+                .filter(Boolean);
+            // Find branch siblings (alternative paths)
+            const alternatives = this.edges
+                .filter(e => e.from === node.id && e.relation === "branch")
+                .map(e => this.nodes.get(e.to)?.thought ?? "")
+                .filter(Boolean);
+            return {
+                step: index + 1,
+                nodeId: node.id,
+                thought: node.thought,
+                score: node.score,
+                confidence: node.confidence,
+                status: node.status,
+                reflections,
+                alternatives,
+            };
+        });
+        return {
+            question: result.path[0].thought,
+            steps,
+            conclusion: result.path[result.path.length - 1].thought,
+            compositeScore: result.totalScore / result.path.length,
+            totalNodes: this.nodes.size,
+            totalEdges: this.edges.length,
+            exportedAt: new Date().toISOString(),
+        };
+    }
 }
 // ==========================================
 // SESSION REGISTRY (replaces singleton)

package/dist/server/http.js

@@ -1,6 +1,7 @@
 import express from "express";
 import cors from "cors";
 import net from "net";
+import crypto from "crypto";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { SERVER_CONFIG } from "../types.js";
 import { getGraphInstance } from "../graph/index.js";
@@ -54,7 +55,7 @@ export async function startHttpServer() {
     app.use(express.json());
     const activeSessions = new Map();
     app.get("/sse", async (req, res) => {
-        const sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        const sessionId = `session_${crypto.randomUUID()}`;
         const transport = new SSEServerTransport("/messages", res);
         const mcpServer = createServerInstance();
         activeSessions.set(sessionId, transport);

package/dist/server/mcp.js

@@ -2,18 +2,19 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { SERVER_CONFIG, RESOURCE_URIS } from "../types.js";
 import { getGraphInstance } from "../graph/index.js";
+import { getContextInstance } from "../context/index.js";
 /**
  * Trigger autonomous LLM audit via MCP Sampling.
  */
 async function triggerAutonomousAudit(server, node, graph) {
-    const auditPrompt = `Please audit this thought node:
-Thought: "${node.thought}"
-Current Score: ${node.score}
-Context Graph: ${JSON.stringify(graph.getSimpleGraph())}
-
-Provide a JSON response with:
-- score: number (0.0 to 1.0)
-- status: "validated" | "rejected" | "branching"
+    const auditPrompt = `Please audit this thought node:
+Thought: "${node.thought}"
+Current Score: ${node.score}
+Context Graph: ${JSON.stringify(graph.getSimpleGraph())}
+
+Provide a JSON response with:
+- score: number (0.0 to 1.0)
+- status: "validated" | "rejected" | "branching"
 - critique: string`;
     try {
         const auditResult = await server.server.request({
@@ -55,6 +56,7 @@ export function createServerInstance() {
         version: SERVER_CONFIG.version,
     });
     const graph = getGraphInstance();
+    const contextStore = getContextInstance();
     // 1. Register Resources
     server.resource("Current Thought Graph", RESOURCE_URIS.currentGraph, async (uri) => ({
         contents: [{
@@ -63,18 +65,30 @@ export function createServerInstance() {
                 mimeType: "application/json"
             }]
     }));
+    // v4.0: Shared Context Store resource (CA-MCP pattern)
+    server.resource("Shared Context Store", RESOURCE_URIS.contextStore, async (uri) => ({
+        contents: [{
+                uri: uri.href,
+                text: JSON.stringify(contextStore.getAll(), null, 2),
+                mimeType: "application/json"
+            }]
+    }));
     // Helper to notify clients of updates
     const notifyUpdate = () => {
         // @ts-ignore - The MCP SDK expects a stricter Notification type intersection
         server.server.notification({ method: "notifications/resources/updated", params: { uri: RESOURCE_URIS.currentGraph } });
     };
     // 2. Register Tools
-    server.tool("propose_thought", "Propose a new unit of reasoning (node) in the thought graph.", {
-        thought: z.string().min(1, "Thought content is required").max(5000, "Thought exceeds 5000 chars").describe("The content of the thought"),
-        parentId: z.string().optional().describe("Optional parent node ID if this thought builds on a previous one"),
-        relation: z.enum(["refinement", "contradiction", "support", "branch"])
-            .default("refinement")
-            .describe("How this thought relates to its parent"),
+    server.registerTool("propose_thought", {
+        description: "Propose a new unit of reasoning (node) in the thought graph.",
+        inputSchema: {
+            thought: z.string().min(1, "Thought content is required").max(5000, "Thought exceeds 5000 chars").describe("The content of the thought"),
+            parentId: z.string().optional().describe("Optional parent node ID if this thought builds on a previous one"),
+            relation: z.enum(["refinement", "contradiction", "support", "branch"])
+                .default("refinement")
+                .describe("How this thought relates to its parent"),
+        },
+        annotations: { destructiveHint: true }
     }, async ({ thought, parentId, relation }) => {
         try {
             const nodeId = graph.addNode(thought);
@@ -94,12 +108,22 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
-    server.tool("evaluate_thought", "Assign a score or status to a thought node. If score is omitted, triggers autonomous LLM audit via sampling.", {
-        nodeId: z.string().min(1, "Node ID is required").describe("The ID of the node to evaluate"),
-        score: z.number().min(0).max(1).optional().describe("Omit to trigger autonomous LLM audit (0.0 to 1.0)"),
-        status: z.enum(["active", "validated", "rejected", "branching"]).optional().describe("Update the node status"),
-        critique: z.string().max(2000, "Critique exceeds 2000 chars").optional().describe("Reasoning for the evaluation"),
-    }, async ({ nodeId, score, status, critique }) => {
+    server.registerTool("evaluate_thought", {
+        description: "Assign a score or status to a thought node. If score is omitted, triggers autonomous LLM audit via sampling.",
+        inputSchema: {
+            nodeId: z.string().min(1, "Node ID is required").describe("The ID of the node to evaluate"),
+            score: z.number().min(0).max(1).optional().describe("Omit to trigger autonomous LLM audit (0.0 to 1.0)"),
+            status: z.enum(["active", "validated", "rejected", "branching"]).optional().describe("Update the node status"),
+            critique: z.string().max(2000, "Critique exceeds 2000 chars").optional().describe("Reasoning for the evaluation"),
+            confidence: z.object({
+                factual: z.number().min(0).max(1).describe("Grounded in verifiable facts"),
+                logical: z.number().min(0).max(1).describe("Reasoning chain is valid"),
+                relevance: z.number().min(0).max(1).describe("Addresses the problem directly"),
+                novelty: z.number().min(0).max(1).describe("Adds new information"),
+            }).optional().describe("v4.0: Multi-dimensional confidence — if provided, composite score is auto-computed"),
+        },
+        annotations: { destructiveHint: true }
+    }, async ({ nodeId, score, status, critique, confidence }) => {
         try {
             const node = graph.getNode(nodeId);
             if (!node) {
@@ -113,8 +137,13 @@ export function createServerInstance() {
                     structuredContent: { nodeId, audited: true, message: auditResult }
                 };
             }
+            // v4.0: if confidence provided, compute composite score automatically
+            const finalScore = confidence
+                ? graph.computeCompositeScore(confidence)
+                : score;
             graph.updateNode(nodeId, {
-                score,
+                score: finalScore,
+                confidence,
                 status: status ?? node.status,
                 metadata: critique ? { critique } : undefined,
             });
@@ -128,14 +157,22 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
-    server.tool("get_thought_graph", "Retrieve the entire current thought graph.", {}, async () => {
+    server.registerTool("get_thought_graph", {
+        description: "Retrieve the entire current thought graph.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true }
+    }, async () => {
         const graphState = graph.getGraph();
         return {
             content: [{ type: "text", text: JSON.stringify(graphState, null, 2) }],
             structuredContent: graphState
         };
     });
-    server.tool("reset_graph", "Clear the current reasoning session, emptying all nodes and edges.", {}, async () => {
+    server.registerTool("reset_graph", {
+        description: "Clear the current reasoning session, emptying all nodes and edges.",
+        inputSchema: {},
+        annotations: { destructiveHint: true }
+    }, async () => {
         graph.clear();
         notifyUpdate();
         return {
@@ -144,10 +181,14 @@ export function createServerInstance() {
         };
     });
     // 3. GoT Primitives — Aggregate, Prune, Converge
-    server.tool("aggregate_thoughts", "GoT Primitive: Merge 2+ thought nodes into a weighted synthesis. Uses formula: Σ(score×weight)/Σ(weights). Retains full provenance and computes aggregation confidence (1 - stddev).", {
-        nodeIds: z.array(z.string()).min(2, "At least 2 node IDs required").describe("Array of node IDs to merge"),
-        synthesis: z.string().min(1, "Synthesis content is required").describe("The merged conclusion that combines insights from all source nodes"),
-        weights: z.array(z.number().min(0).max(1)).optional().describe("Optional per-node weights (defaults to each node's score as its confidence weight)"),
+    server.registerTool("aggregate_thoughts", {
+        description: "GoT Primitive: Merge 2+ thought nodes into a weighted synthesis. Uses formula: Σ(score×weight)/Σ(weights). Retains full provenance and computes aggregation confidence (1 - stddev).",
+        inputSchema: {
+            nodeIds: z.array(z.string()).min(2, "At least 2 node IDs required").describe("Array of node IDs to merge"),
+            synthesis: z.string().min(1, "Synthesis content is required").describe("The merged conclusion that combines insights from all source nodes"),
+            weights: z.array(z.number().min(0).max(1)).optional().describe("Optional per-node weights (defaults to each node's score as its confidence weight)"),
+        },
+        annotations: { destructiveHint: true }
     }, async ({ nodeIds, synthesis, weights }) => {
         try {
             const newId = graph.aggregateNodes(nodeIds, synthesis, weights);
@@ -170,12 +211,16 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
-    server.tool("prune_branch", "GoT Primitive: Recursively reject a node and ALL its descendants. Modes: 'hard' (score=0, status=rejected) or 'soft' (score decayed by factor, status preserved). Tracks trigger origin and original scores.", {
-        nodeId: z.string().min(1, "Node ID is required").describe("The root node of the branch to prune"),
-        reason: z.string().optional().describe("Why this branch is being pruned"),
-        mode: z.enum(["hard", "soft"]).default("hard").describe("'hard' zeroes scores and rejects; 'soft' decays scores while preserving status"),
-        decayFactor: z.number().min(0).max(1).default(0.5).describe("Score multiplier for soft prune (0.5 = halve scores)"),
-        trigger: z.enum(["manual", "auto"]).default("manual").describe("Whether this prune was triggered manually or by an auto-threshold"),
+    server.registerTool("prune_branch", {
+        description: "GoT Primitive: Recursively reject a node and ALL its descendants. Modes: 'hard' (score=0, status=rejected) or 'soft' (score decayed by factor, status preserved). Tracks trigger origin and original scores.",
+        inputSchema: {
+            nodeId: z.string().min(1, "Node ID is required").describe("The root node of the branch to prune"),
+            reason: z.string().optional().describe("Why this branch is being pruned"),
+            mode: z.enum(["hard", "soft"]).default("hard").describe("'hard' zeroes scores and rejects; 'soft' decays scores while preserving status"),
+            decayFactor: z.number().min(0).max(1).default(0.5).describe("Score multiplier for soft prune (0.5 = halve scores)"),
+            trigger: z.enum(["manual", "auto"]).default("manual").describe("Whether this prune was triggered manually or by an auto-threshold"),
+        },
+        annotations: { destructiveHint: true }
     }, async ({ nodeId, reason, mode, decayFactor, trigger }) => {
         try {
             const result = graph.pruneFromNode(nodeId, reason, { mode, decayFactor, trigger });
@@ -195,10 +240,14 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
-    server.tool("find_winning_path", "GoT Primitive: Trace the best scoring path(s) from root to leaf. Default: greedy (beamWidth=1). Set beamWidth>1 for k-best beam search. Supports score threshold gating and path length caps.", {
-        beamWidth: z.number().int().min(1).max(10).default(1).describe("Number of top paths to track (1=greedy DFS, >1=beam search)"),
-        scoreThreshold: z.number().min(0).max(1).default(0).describe("Minimum node score to include in path (filters low-confidence nodes)"),
-        maxPathLength: z.number().int().min(1).default(50).describe("Maximum path depth to prevent runaway traversal"),
+    server.registerTool("find_winning_path", {
+        description: "GoT Primitive: Trace the best scoring path(s) from root to leaf. Default: greedy (beamWidth=1). Set beamWidth>1 for k-best beam search. Supports score threshold gating and path length caps.",
+        inputSchema: {
+            beamWidth: z.number().int().min(1).max(10).default(1).describe("Number of top paths to track (1=greedy DFS, >1=beam search)"),
+            scoreThreshold: z.number().min(0).max(1).default(0).describe("Minimum node score to include in path (filters low-confidence nodes)"),
+            maxPathLength: z.number().int().min(1).default(50).describe("Maximum path depth to prevent runaway traversal"),
+        },
+        annotations: { readOnlyHint: true }
     }, async ({ beamWidth, scoreThreshold, maxPathLength }) => {
         try {
             const result = graph.findWinningPath({ beamWidth, scoreThreshold, maxPathLength });
@@ -232,7 +281,11 @@ export function createServerInstance() {
         }
     });
     // 4. Observability — Graph Metrics
-    server.tool("get_graph_metrics", "Returns structured observability metrics: node count, edge count, max depth, avg score, prune ratio, status breakdown, and root count. Use this to monitor graph health.", {}, async () => {
+    server.registerTool("get_graph_metrics", {
+        description: "Returns structured observability metrics: node count, edge count, max depth, avg score, prune ratio, status breakdown, and root count. Use this to monitor graph health.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true }
+    }, async () => {
         try {
             const metrics = graph.getMetrics();
             const limits = graph.getLimits();
@@ -255,7 +308,11 @@ export function createServerInstance() {
         }
     });
     // 5. Replay — Snapshot Export/Restore
-    server.tool("export_snapshot", "Export a full snapshot of the current graph state for replay, recovery, or debugging. Returns all nodes, edges, and counter as a serializable JSON object.", {}, async () => {
+    server.registerTool("export_snapshot", {
+        description: "Export a full snapshot of the current graph state for replay, recovery, or debugging. Returns all nodes, edges, and counter as a serializable JSON object.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true }
+    }, async () => {
         try {
             const snapshot = graph.exportSnapshot();
             return {
@@ -267,25 +324,29 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
-    server.tool("restore_snapshot", "Restore graph state from a previously exported snapshot. Replaces ALL current state. Use for deterministic replay or recovery.", {
-        snapshot: z.object({
-            nodes: z.array(z.object({
-                id: z.string(),
-                thought: z.string(),
-                status: z.enum(["active", "validated", "rejected", "branching"]),
-                score: z.number(),
-                metadata: z.record(z.any()).optional(),
-                createdAt: z.string(),
-                updatedAt: z.string()
-            })).describe("Array of ThoughtNode objects"),
-            edges: z.array(z.object({
-                from: z.string(),
-                to: z.string(),
-                relation: z.enum(["refinement", "contradiction", "support", "branch", "aggregation"]),
-                createdAt: z.string()
-            })).describe("Array of ThoughtEdge objects"),
-            nodeCounter: z.number().int().min(0).describe("The node counter value from the snapshot"),
-        }).describe("A snapshot object previously returned by export_snapshot"),
+    server.registerTool("restore_snapshot", {
+        description: "Restore graph state from a previously exported snapshot. Replaces ALL current state. Use for deterministic replay or recovery.",
+        inputSchema: {
+            snapshot: z.object({
+                nodes: z.array(z.object({
+                    id: z.string(),
+                    thought: z.string(),
+                    status: z.enum(["active", "validated", "rejected", "branching"]),
+                    score: z.number(),
+                    metadata: z.record(z.string(), z.any()).optional(),
+                    createdAt: z.string(),
+                    updatedAt: z.string()
+                })).describe("Array of ThoughtNode objects"),
+                edges: z.array(z.object({
+                    from: z.string(),
+                    to: z.string(),
+                    relation: z.enum(["refinement", "contradiction", "support", "branch", "aggregation"]),
+                    createdAt: z.string()
+                })).describe("Array of ThoughtEdge objects"),
+                nodeCounter: z.number().int().min(0).describe("The node counter value from the snapshot"),
+            }).describe("A snapshot object previously returned by export_snapshot"),
+        },
+        annotations: { destructiveHint: true }
     }, async ({ snapshot }) => {
         try {
             const beforeCount = graph.size;
@@ -304,5 +365,113 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
+    // ==========================================
+    // v4.0: Self-Reflection Tool (2026 pattern)
+    // ==========================================
+    server.registerTool("reflect_and_refine", {
+        description: "Self-reflection loop: auto-critique a thought, assess confidence on 4 axes (factual, logical, relevance, novelty), and optionally branch a refined version. Implements DeepSeek-R1 self-verification pattern.",
+        inputSchema: {
+            nodeId: z.string().min(1).describe("Node to reflect on"),
+            critique: z.string().min(1).max(5000).describe("Your critique of this thought"),
+            confidence: z.object({
+                factual: z.number().min(0).max(1).describe("Grounded in verifiable facts (0-1)"),
+                logical: z.number().min(0).max(1).describe("Reasoning chain is valid (0-1)"),
+                relevance: z.number().min(0).max(1).describe("Addresses the problem directly (0-1)"),
+                novelty: z.number().min(0).max(1).describe("Adds new information vs restating (0-1)"),
+            }).describe("Multi-dimensional confidence assessment"),
+            refinedThought: z.string().max(5000).optional()
+                .describe("If critique reveals a flaw, provide the improved version to auto-branch"),
+        },
+        annotations: { destructiveHint: true }
+    }, async ({ nodeId, critique, confidence, refinedThought }) => {
+        try {
+            const result = graph.reflectAndRefine(nodeId, critique, confidence, refinedThought);
+            notifyUpdate();
+            const parts = [
+                `Reflection on ${nodeId}: composite score ${result.compositeScore}`,
+                `Critique node: ${result.critiqueId}`,
+            ];
+            if (result.branchId) {
+                parts.push(`Refined branch: ${result.branchId} (auto-branched because score < 0.7)`);
+            }
+            return {
+                content: [{ type: "text", text: parts.join("\n") }],
+                structuredContent: {
+                    nodeId,
+                    critiqueId: result.critiqueId,
+                    branchId: result.branchId ?? null,
+                    compositeScore: result.compositeScore,
+                    confidence,
+                },
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    // ==========================================
+    // v4.0: Shared Context Store Tools (CA-MCP)
+    // ==========================================
+    server.registerTool("context_set", {
+        description: "Write a key-value pair to the shared context store. Tracks source provenance for trust scoring. Use this to share intermediate results between reasoning steps.",
+        inputSchema: {
+            key: z.string().min(1).max(200).describe("Context key (e.g. 'user_requirements', 'domain_constraints')"),
+            value: z.unknown().describe("Any JSON-serializable value"),
+            source: z.string().min(1).max(200).describe("Source of this context (e.g. 'propose_thought:node_3', 'user_input')"),
+        },
+        annotations: { destructiveHint: true }
+    }, async ({ key, value, source }) => {
+        contextStore.set(key, value, source);
+        return {
+            content: [{ type: "text", text: `Context set: ${key} (source: ${source})` }],
+            structuredContent: { key, source, totalEntries: contextStore.size },
+        };
+    });
+    server.registerTool("context_get", {
+        description: "Read a value from the shared context store. Returns value + source provenance. Check context before generating redundant thoughts.",
+        inputSchema: {
+            key: z.string().min(1).describe("Context key to retrieve"),
+        },
+        annotations: { destructiveHint: true }
+    }, async ({ key }) => {
+        const entry = contextStore.getWithProvenance(key);
+        if (!entry) {
+            return { content: [{ type: "text", text: `Context key '${key}' not found` }], isError: true };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(entry, null, 2) }],
+            structuredContent: { key, ...entry },
+        };
+    });
+    server.registerTool("context_list", {
+        description: "List all keys in the shared context store with their sources. Use to see what knowledge is already available before generating new thoughts.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true }
+    }, async () => {
+        const entries = contextStore.list();
+        return {
+            content: [{ type: "text", text: entries.length > 0 ? JSON.stringify(entries, null, 2) : "Context store is empty" }],
+            structuredContent: { entries, count: entries.length },
+        };
+    });
+    // ==========================================
+    // v4.0: Reasoning Trace Export
+    // ==========================================
+    server.registerTool("export_reasoning_trace", {
+        description: "Export the current graph's best reasoning path as a structured trace. Compatible with Long CoT format used by DeepSeek-R1 and o3 for RL training and context.",
+        inputSchema: {},
+        annotations: { readOnlyHint: true }
+    }, async () => {
+        try {
+            const trace = graph.exportReasoningTrace();
+            return {
+                content: [{ type: "text", text: JSON.stringify(trace, null, 2) }],
+                structuredContent: trace,
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
     return server;
 }

package/dist/types.js

@@ -20,13 +20,14 @@ export const DEFAULT_GRAPH_LIMITS = {
  * Server configuration constants.
  */
 export const SERVER_CONFIG = {
-    name: "got-mcp",
-    version: "3.0.0",
-    description: "Graph of Thoughts (GoT) MCP Server — bounded, auditable reasoning",
+    name: "@abderraouf-yt/got-mcp",
+    version: "4.0.0",
+    description: "Graph of Thoughts (GoT) MCP Server — bounded, auditable reasoning with self-reflection and shared context",
 };
 /**
  * Resource URIs used by the server.
  */
 export const RESOURCE_URIS = {
-    currentGraph: "got-mcp://current",
+    currentGraph: "@abderraouf-yt/got-mcp://current",
+    contextStore: "@abderraouf-yt/got-mcp://context",
 };

package/package.json

@@ -1,61 +1,61 @@
-{
-  "name": "@abderraouf-yt/got-mcp",
-  "version": "3.2.0",
-  "description": "Graph of Thoughts (GoT) MCP Server — bounded, auditable reasoning for AI agents",
-  "main": "dist/index.js",
-  "bin": {
-    "got-mcp": "./dist/index.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "type": "module",
-  "license": "MIT",
-  "author": "Abderraouf-yt",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Abderraouf-yt/got-mcp.git"
-  },
-  "homepage": "https://github.com/Abderraouf-yt/got-mcp#readme",
-  "bugs": {
-    "url": "https://github.com/Abderraouf-yt/got-mcp/issues"
-  },
-  "keywords": [
-    "mcp",
-    "model-context-protocol",
-    "graph-of-thoughts",
-    "got",
-    "reasoning",
-    "ai-agents",
-    "dag",
-    "beam-search",
-    "weighted-aggregation",
-    "thought-graph"
-  ],
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "cors": "^2.8.5",
-    "express": "^4.21.0",
-    "zod": "^3.22.4"
-  },
-  "devDependencies": {
-    "@types/cors": "^2.8.17",
-    "@types/express": "^4.17.21",
-    "@types/node": "^20.19.30",
-    "typescript": "^5.9.3"
-  }
+{
+  "name": "@abderraouf-yt/got-mcp",
+  "version": "3.2.1",
+  "description": "Graph of Thoughts (GoT) MCP Server — bounded, auditable reasoning for AI agents",
+  "main": "dist/index.js",
+  "bin": {
+    "got-mcp": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "license": "MIT",
+  "author": "Abderraouf-yt",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Abderraouf-yt/got-mcp.git"
+  },
+  "homepage": "https://github.com/Abderraouf-yt/got-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/Abderraouf-yt/got-mcp/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "graph-of-thoughts",
+    "got",
+    "reasoning",
+    "ai-agents",
+    "dag",
+    "beam-search",
+    "weighted-aggregation",
+    "thought-graph"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.19.30",
+    "typescript": "^5.9.3"
+  }
 }