@iflow-mcp/multimail-dev-thinking-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MultiMail
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# thinking-mcp
+
+MCP server that models how you think. Not what you know.
+
+## Install
+
+```json
+{
+  "mcpServers": {
+    "thinking": {
+      "command": "npx",
+      "args": ["-y", "@multimail/thinking-mcp"],
+      "env": {
+        "ANTHROPIC_API_KEY": "sk-ant-...",
+        "VOYAGE_API_KEY": "pa-..."
+      }
+    }
+  }
+}
+```
+
+Works with Claude Code, Claude Desktop, Cursor, Windsurf, and any MCP client.
+
+## What this is
+
+Every conversation you have contains cognitive patterns you don't notice. Decision rules you apply without naming them. Tensions between things you believe. Assumptions you've never tested.
+
+This server extracts those patterns, stores them in a typed graph, and lets any AI agent query them over MCP. The agent can find contradictions in your thinking, bridge connections between domains you never linked, or predict how you'd approach a decision you haven't faced yet.
+
+It is not a memory system. Memory stores what you said. This models how you decide.
+
+## First run
+
+On first use, the server walks you through a bootstrap conversation. It starts with a real decision you made recently and works backward to understand your heuristics, mental models, and assumptions. Takes about 20 minutes. After that, the extraction pipeline runs against your conversations to build the graph continuously.
+
+The bootstrap tool returns questions for your agent to ask you. You answer naturally. Each answer gets classified and stored as typed nodes in the graph.
+
+## How it works
+
+When you capture text (or an agent does on your behalf), an LLM classifies each statement against an ordered checklist. Is this a decision rule? A framework for thinking? A tension between beliefs? A preference? The checklist forces specific types before falling through to the generic "idea" bucket.
+
+Each node gets:
+- A type (heuristic, mental_model, tension, value, assumption, preference, question, project, idea)
+- An epistemic tag (assertion, hypothesis, speculation)
+- A confidence score (strong, tentative, uncertain)
+- An activation level that decays over time
+
+Typed edges connect nodes: supports, contradicts, evolved_into, depends_on. This makes it a real graph, not a flat embedding store. Agents can traverse relationships, not just retrieve by similarity.
+
+Activation decay means the graph stays current. Values decay slowly. Ideas decay fast. If you haven't revisited or reinforced a pattern in weeks, it fades. Validated heuristics stay hot.
+
+Scoring uses Reciprocal Rank Fusion across vector similarity, keyword matching, and activation. Hub dampening prevents well-connected nodes from dominating every query.
+
+## The extraction problem
+
+You can tell an agent to "capture that thought" mid-conversation. It won't. Not reliably. Agents follow the task at hand and forget side quests.
+
+The real path is a backend pipeline that processes your conversation transcripts on a schedule. Your conversations already contain the patterns. You just need something reading them after the fact.
+
+The capture tool supports both modes. Pass a nodeType and it stores directly. Omit nodeType and it runs inline extraction to classify the text into properly typed nodes.
+
+## Tools
+
+| Tool | What it does | Side effects |
+|------|-------------|-------------|
+| `what_do_i_think` | Query your thinking on a topic | READ-ONLY (bumps activation) |
+| `what_connects` | Find bridges between two domains | READ-ONLY |
+| `what_tensions_exist` | Surface contradictions and weak spots | READ-ONLY |
+| `where_am_i_uncertain` | Find low-confidence or untested patterns | READ-ONLY |
+| `suggest_exploration` | Forgotten patterns near your current context | READ-ONLY |
+| `how_would_user_decide` | Reconstruct reasoning for a new decision | READ-ONLY |
+| `what_has_changed` | Timeline of how your thinking evolved | READ-ONLY |
+| `capture` | Add a thought (with or without inline extraction) | WRITES |
+| `correct` | Fix a node. Strongest learning signal. | WRITES |
+| `record_outcome` | Track what happened after a decision | WRITES |
+| `get_node` | Inspect a node with all its data | READ-ONLY |
+| `get_neighbors` | 1-hop graph traversal from a node | READ-ONLY |
+| `search_nodes` | Keyword search with optional type filter | READ-ONLY |
+| `merge_nodes` | Combine duplicate nodes | DESTRUCTIVE |
+| `archive_node` | Drop a node from results without deleting | WRITES |
+| `bootstrap` | Guided first-run Q&A (5 phases) | WRITES |
+
+## Configuration
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `ANTHROPIC_API_KEY` | Yes | | Claude Haiku for inline extraction |
+| `VOYAGE_API_KEY` | Yes | | Voyage AI for embeddings |
+| `THINKING_MCP_DB_PATH` | No | `~/.thinking-mcp/mind.db` | SQLite database location |
+| `THINKING_MCP_EMBEDDING_PROVIDER` | No | `voyage` | `voyage`, `openai`, or `ollama` |
+
+## What leaves your machine
+
+Embedding text goes to Voyage AI (or your configured provider). Extraction text goes to Anthropic when capture is called without a nodeType. Everything else stays local in SQLite. No telemetry. No analytics.
+
+## Limitations
+
+The vector search is brute-force cosine over all stored embeddings. Fine for personal use up to maybe 100K nodes. Past that you would need a real vector index.
+
+Extraction can hallucinate patterns from weak evidence. The prompt caps at 8 patterns per input and requires explicit evidence for "strong" confidence, but it is still an LLM reading your words and guessing what you meant.
+
+The graph is only as good as the conversations you have. If you only talk about code, it will only model how you think about code.
+
+---
+
+Built by [multimail.dev](https://multimail.dev)

package/dist/bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare function toolBootstrap(action?: string): string;
+export declare function advanceBootstrap(): string;

package/dist/bootstrap.js

@@ -0,0 +1,89 @@
+import { db, persistDb } from "./db.js";
+const PHASES = [
+    {
+        name: "decisions",
+        questions: [
+            "Tell me about a decision you made in the last two weeks.",
+            "What options did you reject?",
+            "What tradeoff mattered most?",
+            "What rule did you apply, even if you didn't name it at the time?",
+        ],
+    },
+    {
+        name: "heuristics",
+        questions: [
+            "When you're stuck on a problem, what's your first move?",
+            "What decision rule do you apply that others might not?",
+            "How do you decide what NOT to work on?",
+        ],
+    },
+    {
+        name: "mental_models",
+        questions: [
+            "What framework do you use repeatedly across different domains?",
+            "How do you evaluate whether an idea is worth pursuing?",
+        ],
+    },
+    {
+        name: "tensions",
+        questions: [
+            "Where do two things you believe pull in opposite directions?",
+            "What tradeoff do you keep revisiting without a clear answer?",
+        ],
+    },
+    {
+        name: "assumptions",
+        questions: [
+            "What do you assume is true that you haven't tested?",
+            "What would change your mind about something you hold strongly?",
+        ],
+    },
+];
+export function toolBootstrap(action) {
+    const phaseRow = db.exec("SELECT value FROM meta WHERE key = 'bootstrap_phase'");
+    const currentPhase = phaseRow.length > 0 && phaseRow[0].values.length > 0 ? parseInt(phaseRow[0].values[0][0]) : 0;
+    const completeRow = db.exec("SELECT value FROM meta WHERE key = 'bootstrap_complete'");
+    const isComplete = completeRow.length > 0 && completeRow[0].values[0]?.[0] === "true";
+    if (action === "status" || isComplete) {
+        const nodeCount = db.exec("SELECT COUNT(*) FROM nodes");
+        const count = nodeCount[0]?.values[0]?.[0] || 0;
+        return JSON.stringify({
+            complete: isComplete,
+            phase: currentPhase,
+            total_phases: PHASES.length,
+            node_count: count,
+            message: isComplete
+                ? `Bootstrap complete. ${count} nodes in the graph. Use capture to keep adding patterns from conversations.`
+                : `Bootstrap in progress. Phase ${currentPhase + 1}/${PHASES.length}: ${PHASES[currentPhase]?.name || "done"}.`,
+        }, null, 2);
+    }
+    if (currentPhase >= PHASES.length) {
+        db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('bootstrap_complete', 'true')");
+        persistDb();
+        return JSON.stringify({ complete: true, message: "All phases done. Bootstrap complete." });
+    }
+    const phase = PHASES[currentPhase];
+    return JSON.stringify({
+        complete: false,
+        phase: currentPhase + 1,
+        phase_name: phase.name,
+        total_phases: PHASES.length,
+        questions: phase.questions,
+        instructions: "Ask the user these questions one at a time. Feed each answer back through the capture tool (without nodeType, so extraction runs automatically). When done with all questions, call bootstrap again to advance to the next phase.",
+        advance: `After capturing answers, call bootstrap with no arguments to move to phase ${currentPhase + 2}.`,
+    }, null, 2);
+}
+export function advanceBootstrap() {
+    const phaseRow = db.exec("SELECT value FROM meta WHERE key = 'bootstrap_phase'");
+    const currentPhase = phaseRow.length > 0 && phaseRow[0].values.length > 0 ? parseInt(phaseRow[0].values[0][0]) : 0;
+    const nextPhase = currentPhase + 1;
+    if (nextPhase >= PHASES.length) {
+        db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('bootstrap_phase', ?)", [String(nextPhase)]);
+        db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('bootstrap_complete', 'true')");
+        persistDb();
+        return JSON.stringify({ complete: true, message: "Bootstrap complete. All phases done." });
+    }
+    db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('bootstrap_phase', ?)", [String(nextPhase)]);
+    persistDb();
+    return toolBootstrap();
+}

package/dist/db.d.ts

@@ -0,0 +1,9 @@
+export type Database = any;
+export declare let db: Database;
+export declare function initDb(): Promise<Database>;
+export declare function persistDb(): void;
+export declare function uuid(): string;
+export declare function now(): string;
+export declare function getNode(nodeId: string): Record<string, unknown> | null;
+export declare function queryNodes(sql: string): Record<string, unknown>[];
+export declare function bumpActivation(nodeId: string): void;

package/dist/db.js

@@ -0,0 +1,190 @@
+// @ts-ignore sql.js has no type declarations
+import initSqlJs from "sql.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { DB_PATH } from "./types.js";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS chunks (
+  id TEXT PRIMARY KEY,
+  text TEXT NOT NULL,
+  source_type TEXT NOT NULL DEFAULT 'capture'
+    CHECK (source_type IN ('capture', 'transcript', 'bootstrap')),
+  epistemic_tag TEXT NOT NULL DEFAULT 'assertion'
+    CHECK (epistemic_tag IN ('assertion', 'hypothesis', 'speculation', 'quoting', 'rejected')),
+  confidence TEXT NOT NULL DEFAULT 'tentative'
+    CHECK (confidence IN ('strong', 'tentative', 'uncertain')),
+  superseded_by TEXT REFERENCES chunks(id),
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL CHECK (type IN (
+    'idea', 'question', 'project',
+    'heuristic', 'value', 'mental_model', 'assumption', 'tension', 'preference'
+  )),
+  summary TEXT NOT NULL,
+  confidence TEXT NOT NULL DEFAULT 'tentative'
+    CHECK (confidence IN ('strong', 'tentative', 'uncertain')),
+  activation REAL NOT NULL DEFAULT 1.0,
+  first_seen TEXT NOT NULL DEFAULT (datetime('now')),
+  last_accessed TEXT NOT NULL DEFAULT (datetime('now')),
+  outcome_score REAL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS node_chunks (
+  node_id TEXT NOT NULL REFERENCES nodes(id),
+  chunk_id TEXT NOT NULL REFERENCES chunks(id),
+  PRIMARY KEY (node_id, chunk_id)
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL CHECK (type IN (
+    'supports', 'contradicts', 'evolved_into', 'inspired_by',
+    'depends_on', 'overrides', 'learned_from', 'scoped_by',
+    'rejected', 'belongs_to', 'derived_from'
+  )),
+  source_node_id TEXT NOT NULL REFERENCES nodes(id),
+  target_node_id TEXT NOT NULL REFERENCES nodes(id),
+  weight REAL NOT NULL DEFAULT 1.0,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS outcomes (
+  id TEXT PRIMARY KEY,
+  node_id TEXT NOT NULL REFERENCES nodes(id),
+  outcome TEXT NOT NULL,
+  score REAL NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS embeddings (
+  chunk_id TEXT PRIMARY KEY REFERENCES chunks(id),
+  vector TEXT NOT NULL,
+  model TEXT NOT NULL,
+  dims INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS framing (
+  id TEXT PRIMARY KEY,
+  question TEXT NOT NULL,
+  rationale TEXT,
+  priority INTEGER NOT NULL DEFAULT 0,
+  version INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS traces (
+  id TEXT PRIMARY KEY,
+  tool_name TEXT NOT NULL,
+  query_text TEXT,
+  node_ids_touched TEXT,
+  agent_name TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+CREATE INDEX IF NOT EXISTS idx_nodes_activation ON nodes(activation DESC);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_node_id);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_node_id);
+CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+CREATE INDEX IF NOT EXISTS idx_outcomes_node ON outcomes(node_id);
+CREATE INDEX IF NOT EXISTS idx_framing_priority ON framing(priority);
+`;
+function ensureDir(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+export let db;
+export async function initDb() {
+    const SQL = await initSqlJs();
+    ensureDir(DB_PATH);
+    if (fs.existsSync(DB_PATH)) {
+        const buf = fs.readFileSync(DB_PATH);
+        db = new SQL.Database(buf);
+    }
+    else {
+        db = new SQL.Database();
+    }
+    db.run("PRAGMA foreign_keys = ON;");
+    db.run(SCHEMA);
+    seedDefaultFraming();
+    persistDb();
+    return db;
+}
+/**
+ * Seeds framing directives from framing.yaml if the framing table is empty.
+ * framing.yaml ships with starter directives — users replace them with their own.
+ */
+function seedDefaultFraming() {
+    const existing = db.exec("SELECT COUNT(*) FROM framing");
+    const count = existing.length > 0 ? existing[0].values[0][0] : 0;
+    if (count > 0)
+        return;
+    const candidates = [
+        path.resolve(__dirname, "..", "framing.yaml"),
+        path.resolve(__dirname, "..", "..", "framing.yaml"),
+    ];
+    const yamlPath = candidates.find((p) => fs.existsSync(p));
+    if (!yamlPath) {
+        console.warn("framing.yaml not found — use seed_framing to add directives.");
+        return;
+    }
+    const raw = fs.readFileSync(yamlPath, "utf-8");
+    const parsed = yaml.load(raw);
+    if (!parsed?.directives?.length)
+        return;
+    for (const d of parsed.directives) {
+        db.run("INSERT INTO framing (id, question, rationale, priority, version) VALUES (?, ?, ?, ?, ?)", [d.id, d.question, d.rationale ?? null, d.priority, d.version ?? 1]);
+    }
+}
+export function persistDb() {
+    const data = db.export();
+    const buffer = Buffer.from(data);
+    const tmp = DB_PATH + ".tmp";
+    ensureDir(DB_PATH);
+    fs.writeFileSync(tmp, buffer);
+    fs.renameSync(tmp, DB_PATH);
+}
+export function uuid() {
+    return crypto.randomUUID();
+}
+export function now() {
+    return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+export function getNode(nodeId) {
+    const rows = db.exec(`SELECT * FROM nodes WHERE id = '${nodeId}'`);
+    if (rows.length === 0 || rows[0].values.length === 0)
+        return null;
+    const cols = rows[0].columns;
+    const vals = rows[0].values[0];
+    const obj = {};
+    cols.forEach((c, i) => { obj[c] = vals[i]; });
+    return obj;
+}
+export function queryNodes(sql) {
+    const rows = db.exec(sql);
+    if (rows.length === 0)
+        return [];
+    return rows[0].values.map((vals) => {
+        const obj = {};
+        rows[0].columns.forEach((c, i) => { obj[c] = vals[i]; });
+        return obj;
+    });
+}
+export function bumpActivation(nodeId) {
+    db.run(`UPDATE nodes SET activation = MIN(activation + 0.1, 1.0), last_accessed = '${now()}' WHERE id = '${nodeId}'`);
+}

package/dist/embed.d.ts

@@ -0,0 +1,13 @@
+export declare let embeddingModel: string;
+export declare let embeddingDims: number;
+export declare function embed(texts: string[]): Promise<number[][]>;
+export declare function embedOne(text: string): Promise<number[] | null>;
+export declare function validateDims(vector: number[]): boolean;
+export declare function cosine(a: number[], b: number[]): number;
+export declare function vectorSearch(queryVec: number[], topK?: number): {
+    chunkId: string;
+    score: number;
+}[];
+export declare function rrfFuse(rankings: Map<string, number>[], weights?: number[]): Map<string, number>;
+export declare function decayedActivation(activation: number, lastAccessed: string, nodeType: string): number;
+export declare function hubDampen(nodeId: string, score: number): number;

package/dist/embed.js

@@ -0,0 +1,127 @@
+import { EMBEDDING_PROVIDER, VOYAGE_API_KEY, OPENAI_API_KEY, OLLAMA_URL } from "./types.js";
+import { db } from "./db.js";
+import { DECAY_RATES } from "./types.js";
+export let embeddingModel = "";
+export let embeddingDims = 0;
+export async function embed(texts) {
+    if (EMBEDDING_PROVIDER === "voyage") {
+        if (!VOYAGE_API_KEY)
+            throw new Error("VOYAGE_API_KEY required for voyage embeddings");
+        const resp = await fetch("https://api.voyageai.com/v1/embeddings", {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${VOYAGE_API_KEY}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ model: "voyage-3-lite", input: texts, input_type: "document" }),
+        });
+        if (!resp.ok)
+            throw new Error(`Voyage API error: ${resp.status} ${await resp.text()}`);
+        const json = await resp.json();
+        const vectors = json.data.map(d => d.embedding);
+        if (vectors.length > 0) {
+            embeddingModel = "voyage-3-lite";
+            embeddingDims = vectors[0].length;
+        }
+        return vectors;
+    }
+    if (EMBEDDING_PROVIDER === "openai") {
+        if (!OPENAI_API_KEY)
+            throw new Error("OPENAI_API_KEY required for openai embeddings");
+        const resp = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${OPENAI_API_KEY}`, "Content-Type": "application/json" },
+            body: JSON.stringify({ model: "text-embedding-3-small", input: texts }),
+        });
+        if (!resp.ok)
+            throw new Error(`OpenAI API error: ${resp.status} ${await resp.text()}`);
+        const json = await resp.json();
+        const vectors = json.data.map(d => d.embedding);
+        if (vectors.length > 0) {
+            embeddingModel = "text-embedding-3-small";
+            embeddingDims = vectors[0].length;
+        }
+        return vectors;
+    }
+    if (EMBEDDING_PROVIDER === "ollama") {
+        const vectors = [];
+        for (const text of texts) {
+            const resp = await fetch(`${OLLAMA_URL}/api/embeddings`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ model: "nomic-embed-text", prompt: text }),
+            });
+            if (!resp.ok)
+                throw new Error(`Ollama error: ${resp.status}`);
+            const json = await resp.json();
+            vectors.push(json.embedding);
+        }
+        if (vectors.length > 0) {
+            embeddingModel = "nomic-embed-text";
+            embeddingDims = vectors[0].length;
+        }
+        return vectors;
+    }
+    throw new Error(`Unknown embedding provider: ${EMBEDDING_PROVIDER}`);
+}
+export async function embedOne(text) {
+    try {
+        const result = await embed([text]);
+        return result[0] ?? null;
+    }
+    catch (e) {
+        console.error("Embedding error:", e);
+        return null;
+    }
+}
+export function validateDims(vector) {
+    if (embeddingDims === 0)
+        return true;
+    return vector.length === embeddingDims;
+}
+export function cosine(a, b) {
+    let dot = 0, magA = 0, magB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        magA += a[i] * a[i];
+        magB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(magA) * Math.sqrt(magB);
+    return denom === 0 ? 0 : dot / denom;
+}
+export function vectorSearch(queryVec, topK = 20) {
+    const rows = db.exec("SELECT chunk_id, vector FROM embeddings");
+    if (rows.length === 0 || rows[0].values.length === 0)
+        return [];
+    const scored = [];
+    for (const row of rows[0].values) {
+        const chunkId = row[0];
+        const vec = JSON.parse(row[1]);
+        if (vec.length !== queryVec.length)
+            continue;
+        scored.push({ chunkId, score: cosine(queryVec, vec) });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK);
+}
+export function rrfFuse(rankings, weights) {
+    const k = 60;
+    const fused = new Map();
+    rankings.forEach((ranking, i) => {
+        const w = weights?.[i] ?? 1;
+        const sorted = [...ranking.entries()].sort((a, b) => b[1] - a[1]);
+        sorted.forEach(([id], rank) => {
+            fused.set(id, (fused.get(id) || 0) + w / (k + rank + 1));
+        });
+    });
+    return fused;
+}
+export function decayedActivation(activation, lastAccessed, nodeType) {
+    const days = (Date.now() - new Date(lastAccessed).getTime()) / 86400000;
+    const rate = DECAY_RATES[nodeType] || 0.95;
+    return Math.max(activation * Math.pow(rate, days), 0.01);
+}
+export function hubDampen(nodeId, score) {
+    const result = db.exec(`SELECT COUNT(*) FROM edges WHERE source_node_id = '${nodeId}' OR target_node_id = '${nodeId}'`);
+    const edgeCount = result[0]?.values[0]?.[0] || 0;
+    if (edgeCount > 10)
+        return score / Math.log2(edgeCount);
+    return score;
+}

package/dist/extract.d.ts

@@ -0,0 +1,2 @@
+import type { ExtractedPattern } from "./types.js";
+export declare function extractPatterns(text: string): Promise<ExtractedPattern[]>;

package/dist/extract.js

@@ -0,0 +1,58 @@
+import { ANTHROPIC_API_KEY, VALID_NODE_TYPES, VALID_CONFIDENCE, VALID_EPISTEMIC_TAGS } from "./types.js";
+const EXTRACTION_PROMPT = `You are extracting cognitive patterns from text. Extract ONLY patterns that reveal how the user thinks, decides, or evaluates.
+
+For each pattern, output a JSON object:
+- "text": The pattern in the user's voice
+- "type": One of: heuristic, mental_model, preference, value, assumption, tension, question, project, idea
+- "confidence": strong | tentative | uncertain
+- "epistemic": assertion | hypothesis | speculation
+
+Type selection, work through IN ORDER (do NOT default to "idea"):
+1. Decision rule or "when X, do Y"? -> heuristic
+2. Framework for thinking about a domain? -> mental_model
+3. Conflict or tradeoff between held beliefs? -> tension
+4. What the user prefers, likes, or chooses? -> preference
+5. Core principle or what they care about? -> value
+6. Something taken as given that could be wrong? -> assumption
+7. Active question being investigated? -> question
+8. Ongoing effort with a goal? -> project
+9. ONLY if none above -> idea
+
+Rules: 0-8 patterns max. Quality over quantity. Corrections are strongest signal. "idea" should be RARE.
+Output a JSON array. [] if none found.
+
+Text to analyze:
+`;
+export async function extractPatterns(text) {
+    if (!ANTHROPIC_API_KEY)
+        return [];
+    try {
+        const resp = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "x-api-key": ANTHROPIC_API_KEY,
+                "content-type": "application/json",
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify({
+                model: "claude-haiku-4-5-20251001",
+                max_tokens: 1024,
+                messages: [{ role: "user", content: EXTRACTION_PROMPT + text }],
+            }),
+        });
+        if (!resp.ok)
+            return [];
+        const json = await resp.json();
+        const content = json.content?.[0]?.text || "";
+        const match = content.match(/\[[\s\S]*\]/);
+        if (!match)
+            return [];
+        const parsed = JSON.parse(match[0]);
+        return parsed.filter(p => p.text && p.type && VALID_NODE_TYPES.has(p.type) &&
+            VALID_CONFIDENCE.has(p.confidence || "tentative") &&
+            VALID_EPISTEMIC_TAGS.has(p.epistemic || "assertion"));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// thinking-mcp: MCP server that models how you think
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { initDb, db, uuid, persistDb } from "./db.js";
+import { toolPing, toolCapture, toolWhatDoIThink, toolWhatConnects, toolWhatTensionsExist, toolWhereAmIUncertain, toolSuggestExploration, toolHowWouldUserDecide, toolWhatHasChanged, toolCorrect, toolRecordOutcome, toolGetNode, toolGetNeighbors, toolSearchNodes, toolMergeNodes, toolArchiveNode } from "./tools.js";
+import { toolBootstrap, advanceBootstrap } from "./bootstrap.js";
+async function main() {
+    await initDb();
+    const server = new McpServer({ name: "thinking-mcp", version: "0.2.0" });
+    // --- get_framing (call FIRST on every substantive query) ---
+    server.tool("get_framing", "Get framing directives — lens-shaping questions that must be answered before any substantive response. CALL THIS FIRST on any substantive query, unconditionally. Framing is architecturally separated from knowledge retrieval: not activation-ranked, not similarity-matched — loaded verbatim, always. Answer each question visibly in your response, or state explicitly which you are skipping and why. READ-ONLY but traces every invocation. Hard-capped at 5.", {}, () => {
+        const rows = db.exec("SELECT id, question, rationale, priority, version FROM framing ORDER BY priority ASC, id ASC");
+        const directives = rows.length > 0 ? rows[0].values.map((v) => ({
+            id: v[0], question: v[1], rationale: v[2], priority: v[3], version: v[4],
+        })) : [];
+        const traceId = uuid();
+        db.run(`INSERT INTO traces (id, tool_name, node_ids_touched) VALUES (?, 'get_framing', ?)`, [traceId, JSON.stringify(directives.map((d) => d.id))]);
+        persistDb();
+        const result = directives.length === 0
+            ? { directives: [], warning: "No framing directives configured. Use seed_framing or add a framing.yaml file.", trace_id: traceId }
+            : { directives, count: directives.length, protocol: "Answer each question visibly in your response, or state explicitly which you are skipping and why.", trace_id: traceId };
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // --- seed_framing ---
+    server.tool("seed_framing", "Seed or replace all framing directives. Hard-capped at 5. DESTRUCTIVE: replaces all existing directives. Each directive needs id, question, priority. Write your own — these are the questions that shape how you think before acting.", { directives: z.array(z.object({ id: z.string(), question: z.string(), rationale: z.string().optional(), priority: z.number().default(0) })).max(5).describe("Array of framing directives (max 5)") }, ({ directives }) => {
+        db.run("DELETE FROM framing");
+        for (const d of directives) {
+            db.run("INSERT INTO framing (id, question, rationale, priority, version) VALUES (?, ?, ?, ?, 1)", [d.id, d.question, d.rationale ?? null, d.priority]);
+        }
+        persistDb();
+        return { content: [{ type: "text", text: JSON.stringify({ seeded: directives.length, ids: directives.map(d => d.id) }) }] };
+    });
+    server.tool("ping", "Health check. Returns node count, chunk count, and DB path. READ-ONLY.", {}, () => ({ content: [{ type: "text", text: toolPing() }] }));
+    server.tool("capture", "Capture a thought into the cognitive graph. If nodeType is provided, stores as that type directly. If omitted, runs inline extraction to classify the text into properly typed nodes. WRITES to SQLite. Does NOT create edges between nodes.", {
+        text: z.string().describe("The thought, observation, or raw text to capture"),
+        nodeType: z.string().optional().describe("Optional. Skips extraction if provided. Valid: idea, question, heuristic, value, mental_model, assumption, tension, preference, project"),
+        epistemicTag: z.string().default("assertion").describe("assertion, hypothesis, speculation, quoting, rejected"),
+        confidence: z.string().default("tentative").describe("strong, tentative, uncertain"),
+    }, async ({ text, nodeType, epistemicTag, confidence }) => ({ content: [{ type: "text", text: await toolCapture(text, nodeType, epistemicTag, confidence) }] }));
+    server.tool("what_do_i_think", "Query your thinking on a topic. Returns nodes ranked by relevance and activation. READ-ONLY (but bumps activation on accessed nodes). Use this before capture to check if a pattern already exists.", { topic: z.string().describe("The topic to explore your thinking on") }, async ({ topic }) => ({ content: [{ type: "text", text: await toolWhatDoIThink(topic) }] }));
+    server.tool("what_connects", "Find unexpected bridges between two domains. Scores every process node against both domains and returns those relevant to both. READ-ONLY. Hub dampening applied.", { domain_a: z.string().describe("First domain"), domain_b: z.string().describe("Second domain") }, async ({ domain_a, domain_b }) => ({ content: [{ type: "text", text: await toolWhatConnects(domain_a, domain_b) }] }));
+    server.tool("what_tensions_exist", "Surface contradictions and weak spots. Finds tension nodes, contradicts edges, and low-confidence assumptions. READ-ONLY. Optional topic filter.", { topic: z.string().optional().describe("Optional topic to focus on") }, async ({ topic }) => ({ content: [{ type: "text", text: await toolWhatTensionsExist(topic) }] }));
+    server.tool("where_am_i_uncertain", "Find areas of low confidence or untested patterns. READ-ONLY. Optional domain filter.", { domain: z.string().optional().describe("Optional domain to focus on") }, async ({ domain }) => ({ content: [{ type: "text", text: await toolWhereAmIUncertain(domain) }] }));
+    server.tool("suggest_exploration", "Surface forgotten patterns relevant to your current context. Finds low-activation nodes semantically close to what you're working on. READ-ONLY. Use for creative cross-pollination.", { current_context: z.string().describe("What you're currently working on or thinking about") }, async ({ current_context }) => ({ content: [{ type: "text", text: await toolSuggestExploration(current_context) }] }));
+    server.tool("how_would_user_decide", "Reason through a decision using captured heuristics, values, and mental models. Returns relevant patterns grouped by type. READ-ONLY. Does NOT make the decision.", { context: z.string().describe("The decision context"), options: z.string().optional().describe("Comma-separated options being considered") }, async ({ context, options }) => ({ content: [{ type: "text", text: await toolHowWouldUserDecide(context, options) }] }));
+    server.tool("what_has_changed", "Show how your thinking on a topic has evolved over time. Returns a timeline of nodes, evolution chains, and outcome history. READ-ONLY.", { domain: z.string().describe("The domain to check evolution on") }, async ({ domain }) => ({ content: [{ type: "text", text: await toolWhatHasChanged(domain) }] }));
+    server.tool("correct", "Correct a node in the graph. Updates summary, supersedes old chunks, boosts activation +2.0. Strongest learning signal. WRITES to SQLite.", { node_id: z.string().describe("The node ID to correct"), new_summary: z.string().describe("The corrected summary"), new_confidence: z.string().optional().describe("Updated confidence: strong, tentative, uncertain") }, async ({ node_id, new_summary, new_confidence }) => ({ content: [{ type: "text", text: await toolCorrect(node_id, new_summary, new_confidence) }] }));
+    server.tool("record_outcome", "Record what happened after a decision influenced by a node. Writes to outcomes table and updates the node's track record. WRITES to SQLite.", { node_id: z.string().describe("The node that influenced the decision"), outcome: z.string().describe("What happened"), score: z.number().describe("Outcome quality from -1.0 (terrible) to 1.0 (excellent)") }, ({ node_id, outcome, score }) => ({ content: [{ type: "text", text: toolRecordOutcome(node_id, outcome, score) }] }));
+    server.tool("get_node", "Get a node by ID with all chunks, edges, and outcome history. READ-ONLY. Use before correcting, merging, or archiving.", { node_id: z.string().describe("The node ID") }, ({ node_id }) => ({ content: [{ type: "text", text: toolGetNode(node_id) }] }));
+    server.tool("get_neighbors", "Get all nodes connected to a node via edges (1-hop). READ-ONLY. Returns the node, its neighbors, and connecting edges.", { node_id: z.string().describe("The node ID") }, ({ node_id }) => ({ content: [{ type: "text", text: toolGetNeighbors(node_id) }] }));
+    server.tool("search_nodes", "Keyword search across node summaries with optional type filter. Up to 20 results ranked by activation. READ-ONLY. For semantic search, use what_do_i_think instead.", { query: z.string().describe("Keyword to search for"), nodeType: z.string().optional().describe("Optional type filter") }, ({ query, nodeType }) => ({ content: [{ type: "text", text: toolSearchNodes(query, nodeType) }] }));
+    server.tool("merge_nodes", "Merge two duplicate nodes. Keeps the first, transfers chunks/edges/outcomes from the second, deletes the second. DESTRUCTIVE. Use get_node on both first.", { keep_id: z.string().describe("The node ID to keep"), merge_id: z.string().describe("The node ID to merge and delete") }, ({ keep_id, merge_id }) => ({ content: [{ type: "text", text: toolMergeNodes(keep_id, merge_id) }] }));
+    server.tool("archive_node", "Set a node's activation to 0. It stays in the graph but drops out of results. WRITES. Prefer correct if the node needs updating rather than removal.", { node_id: z.string().describe("The node ID to archive") }, ({ node_id }) => ({ content: [{ type: "text", text: toolArchiveNode(node_id) }] }));
+    server.tool("bootstrap", "Guided first-run experience. Returns questions for the agent to ask the user across 5 phases. Feed answers back through capture (without nodeType). Call again with no args to advance phases. Tracks phase state in meta table.", { action: z.string().optional().describe("'start' to begin or resume, 'status' to check progress, omit to advance to next phase") }, ({ action }) => {
+        const text = action === "start" || action === "status" ? toolBootstrap(action) : advanceBootstrap();
+        return { content: [{ type: "text", text }] };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(e => { console.error("Fatal:", e); process.exit(1); });

package/dist/tools.d.ts

@@ -0,0 +1,16 @@
+export declare function toolPing(): string;
+export declare function toolCapture(text: string, nodeType?: string, epistemicTag?: string, confidence?: string): Promise<string>;
+export declare function toolWhatDoIThink(topic: string): Promise<string>;
+export declare function toolWhatConnects(domainA: string, domainB: string): Promise<string>;
+export declare function toolWhatTensionsExist(topic?: string): Promise<string>;
+export declare function toolWhereAmIUncertain(domain?: string): Promise<string>;
+export declare function toolSuggestExploration(currentContext: string): Promise<string>;
+export declare function toolHowWouldUserDecide(context: string, options?: string): Promise<string>;
+export declare function toolWhatHasChanged(domain: string): Promise<string>;
+export declare function toolCorrect(nodeId: string, newSummary: string, newConfidence?: string): Promise<string>;
+export declare function toolRecordOutcome(nodeId: string, outcome: string, score: number): string;
+export declare function toolGetNode(nodeId: string): string;
+export declare function toolGetNeighbors(nodeId: string): string;
+export declare function toolSearchNodes(query: string, nodeType?: string): string;
+export declare function toolMergeNodes(keepId: string, mergeId: string): string;
+export declare function toolArchiveNode(nodeId: string): string;

package/dist/tools.js

@@ -0,0 +1,432 @@
+import { VALID_NODE_TYPES } from "./types.js";
+import { db, persistDb, uuid, now, getNode, queryNodes, bumpActivation } from "./db.js";
+import { embedOne, validateDims, embeddingModel, embeddingDims, vectorSearch, cosine, rrfFuse, decayedActivation, hubDampen } from "./embed.js";
+import { extractPatterns } from "./extract.js";
+import { DB_PATH } from "./types.js";
+// ---------------------------------------------------------------------------
+// ping
+// ---------------------------------------------------------------------------
+export function toolPing() {
+    const nodeCount = db.exec("SELECT COUNT(*) FROM nodes");
+    const chunkCount = db.exec("SELECT COUNT(*) FROM chunks");
+    const n = nodeCount[0]?.values[0]?.[0] || 0;
+    const c = chunkCount[0]?.values[0]?.[0] || 0;
+    return `thinking-mcp online. ${n} nodes, ${c} chunks. DB: ${DB_PATH}`;
+}
+// ---------------------------------------------------------------------------
+// capture
+// ---------------------------------------------------------------------------
+export async function toolCapture(text, nodeType, epistemicTag = "assertion", confidence = "tentative") {
+    if (nodeType && VALID_NODE_TYPES.has(nodeType)) {
+        const chunkId = uuid(), nodeId = uuid();
+        const vec = await embedOne(text);
+        if (!vec)
+            return "Error: failed to generate embedding";
+        if (!validateDims(vec))
+            return "Error: embedding dimension mismatch";
+        db.run("INSERT INTO chunks (id, text, source_type, epistemic_tag, confidence) VALUES (?, ?, 'capture', ?, ?)", [chunkId, text, epistemicTag, confidence]);
+        db.run("INSERT INTO nodes (id, type, summary, confidence, activation) VALUES (?, ?, ?, ?, 1.0)", [nodeId, nodeType, text, confidence]);
+        db.run("INSERT INTO node_chunks (node_id, chunk_id) VALUES (?, ?)", [nodeId, chunkId]);
+        db.run("INSERT INTO embeddings (chunk_id, vector, model, dims) VALUES (?, ?, ?, ?)", [chunkId, JSON.stringify(vec), embeddingModel, embeddingDims]);
+        persistDb();
+        return `Captured as ${nodeType} (${epistemicTag}, ${confidence}). Node: ${nodeId}`;
+    }
+    const patterns = await extractPatterns(text);
+    if (patterns.length === 0) {
+        const chunkId = uuid(), nodeId = uuid();
+        const vec = await embedOne(text);
+        if (!vec)
+            return "Error: failed to generate embedding";
+        db.run("INSERT INTO chunks (id, text, source_type, epistemic_tag, confidence) VALUES (?, ?, 'capture', ?, ?)", [chunkId, text, epistemicTag, confidence]);
+        db.run("INSERT INTO nodes (id, type, summary, confidence, activation) VALUES (?, ?, ?, ?, 1.0)", [nodeId, "idea", text, confidence]);
+        db.run("INSERT INTO node_chunks (node_id, chunk_id) VALUES (?, ?)", [nodeId, chunkId]);
+        db.run("INSERT INTO embeddings (chunk_id, vector, model, dims) VALUES (?, ?, ?, ?)", [chunkId, JSON.stringify(vec), embeddingModel, embeddingDims]);
+        persistDb();
+        return `No patterns extracted. Stored as idea. Node: ${nodeId}`;
+    }
+    const nodeIds = [];
+    for (const p of patterns) {
+        const chunkId = uuid(), nodeId = uuid();
+        const vec = await embedOne(p.text);
+        if (!vec)
+            continue;
+        db.run("INSERT INTO chunks (id, text, source_type, epistemic_tag, confidence) VALUES (?, ?, 'capture', ?, ?)", [chunkId, p.text, p.epistemic || "assertion", p.confidence || "tentative"]);
+        db.run("INSERT INTO nodes (id, type, summary, confidence, activation) VALUES (?, ?, ?, ?, 1.0)", [nodeId, p.type, p.text, p.confidence || "tentative"]);
+        db.run("INSERT INTO node_chunks (node_id, chunk_id) VALUES (?, ?)", [nodeId, chunkId]);
+        db.run("INSERT INTO embeddings (chunk_id, vector, model, dims) VALUES (?, ?, ?, ?)", [chunkId, JSON.stringify(vec), embeddingModel, embeddingDims]);
+        nodeIds.push(nodeId);
+    }
+    persistDb();
+    const summary = patterns.map(p => `${p.type}: "${p.text.slice(0, 50)}"`).join("; ");
+    return `Extracted ${patterns.length} pattern(s): ${summary}`;
+}
+// ---------------------------------------------------------------------------
+// what_do_i_think
+// ---------------------------------------------------------------------------
+export async function toolWhatDoIThink(topic) {
+    const queryVec = await embedOne(topic);
+    if (!queryVec)
+        return "Error: failed to embed query";
+    const vectorHits = vectorSearch(queryVec, 40);
+    const vectorScores = new Map();
+    for (const h of vectorHits) {
+        const nc = db.exec(`SELECT node_id FROM node_chunks WHERE chunk_id = '${h.chunkId}'`);
+        if (nc.length > 0) {
+            for (const row of nc[0].values) {
+                const nid = row[0];
+                vectorScores.set(nid, Math.max(vectorScores.get(nid) || 0, h.score));
+            }
+        }
+    }
+    const kw = topic.split(/\s+/).filter(w => w.length > 3).map(w => `summary LIKE '%${w}%'`).join(" OR ");
+    const keywordScores = new Map();
+    if (kw) {
+        const kwNodes = queryNodes(`SELECT id, activation FROM nodes WHERE ${kw} LIMIT 20`);
+        kwNodes.forEach((n, i) => { keywordScores.set(n.id, 1 / (i + 1)); });
+    }
+    const allIds = new Set([...vectorScores.keys(), ...keywordScores.keys()]);
+    const activationScores = new Map();
+    const outcomeScores = new Map();
+    for (const id of allIds) {
+        const node = getNode(id);
+        if (!node)
+            continue;
+        activationScores.set(id, decayedActivation(node.activation, node.last_accessed, node.type));
+        outcomeScores.set(id, node.outcome_score ?? 0);
+    }
+    // Weights: vector 3x, keyword 3x, activation 1x, outcome 0.5x
+    const fused = rrfFuse([vectorScores, keywordScores, activationScores, outcomeScores], [3, 3, 1, 0.5]);
+    const ranked = [...fused.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20);
+    for (const [id] of ranked)
+        bumpActivation(id);
+    const positions = ranked.map(([id]) => {
+        const node = getNode(id);
+        if (!node)
+            return null;
+        return {
+            type: node.type, summary: node.summary, confidence: node.confidence,
+            activation: decayedActivation(node.activation, node.last_accessed, node.type).toFixed(3),
+            outcome_score: node.outcome_score,
+            first_seen: node.first_seen,
+        };
+    }).filter(Boolean);
+    persistDb();
+    return JSON.stringify({ topic, positions, node_count: positions.length }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// what_connects
+// ---------------------------------------------------------------------------
+export async function toolWhatConnects(domainA, domainB) {
+    const vecA = await embedOne(domainA);
+    const vecB = await embedOne(domainB);
+    if (!vecA || !vecB)
+        return "Error: failed to embed domains";
+    const processTypes = new Set(["heuristic", "value", "mental_model", "tension", "assumption", "preference"]);
+    const allNodes = queryNodes("SELECT * FROM nodes");
+    const bridges = [];
+    for (const node of allNodes) {
+        if (!processTypes.has(node.type))
+            continue;
+        const chunks = db.exec(`SELECT chunk_id FROM node_chunks WHERE node_id = '${node.id}'`);
+        if (chunks.length === 0)
+            continue;
+        let bestScoreA = 0, bestScoreB = 0;
+        for (const row of chunks[0].values) {
+            const embRow = db.exec(`SELECT vector FROM embeddings WHERE chunk_id = '${row[0]}'`);
+            if (embRow.length === 0)
+                continue;
+            const vec = JSON.parse(embRow[0].values[0][0]);
+            bestScoreA = Math.max(bestScoreA, cosine(vecA, vec));
+            bestScoreB = Math.max(bestScoreB, cosine(vecB, vec));
+        }
+        const minScore = Math.min(bestScoreA, bestScoreB);
+        if (minScore > 0.18) {
+            bridges.push({ id: node.id, type: node.type, summary: node.summary, scoreA: bestScoreA, scoreB: bestScoreB, min: hubDampen(node.id, minScore) });
+        }
+    }
+    bridges.sort((a, b) => b.min - a.min);
+    return JSON.stringify({ domain_a: domainA, domain_b: domainB, bridges: bridges.slice(0, 10) }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// what_tensions_exist
+// ---------------------------------------------------------------------------
+export async function toolWhatTensionsExist(topic) {
+    let tensionNodes = queryNodes("SELECT * FROM nodes WHERE type = 'tension'");
+    const contradictEdges = queryNodes("SELECT * FROM edges WHERE type = 'contradicts'");
+    const weakAssumptions = queryNodes("SELECT * FROM nodes WHERE type = 'assumption' AND (confidence = 'uncertain' OR confidence = 'tentative')");
+    if (topic) {
+        const vec = await embedOne(topic);
+        if (vec) {
+            const hits = vectorSearch(vec, 40);
+            const relevantChunks = new Set(hits.filter(h => h.score > 0.2).map(h => h.chunkId));
+            const relevantNodes = new Set();
+            for (const cid of relevantChunks) {
+                const nc = db.exec(`SELECT node_id FROM node_chunks WHERE chunk_id = '${cid}'`);
+                if (nc.length > 0)
+                    nc[0].values.forEach((r) => relevantNodes.add(r[0]));
+            }
+            tensionNodes = tensionNodes.filter(n => relevantNodes.has(n.id));
+        }
+    }
+    return JSON.stringify({
+        explicit_tensions: tensionNodes.map(n => ({ type: n.type, summary: n.summary, confidence: n.confidence })),
+        contradictions: contradictEdges.map(e => ({ source: e.source_node_id, target: e.target_node_id, weight: e.weight })),
+        weak_assumptions: weakAssumptions.map(n => ({ summary: n.summary, confidence: n.confidence })),
+    }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// where_am_i_uncertain
+// ---------------------------------------------------------------------------
+export async function toolWhereAmIUncertain(domain) {
+    let nodes = queryNodes("SELECT * FROM nodes WHERE confidence IN ('uncertain', 'tentative') OR (type IN ('heuristic', 'mental_model', 'assumption') AND outcome_score IS NULL)");
+    if (domain) {
+        const vec = await embedOne(domain);
+        if (vec) {
+            const hits = vectorSearch(vec, 40);
+            const relevantNodes = new Set();
+            for (const h of hits) {
+                const nc = db.exec(`SELECT node_id FROM node_chunks WHERE chunk_id = '${h.chunkId}'`);
+                if (nc.length > 0)
+                    nc[0].values.forEach((r) => relevantNodes.add(r[0]));
+            }
+            nodes = nodes.filter(n => relevantNodes.has(n.id));
+        }
+    }
+    return JSON.stringify({
+        uncertain: nodes.filter(n => n.confidence === "uncertain").map(n => ({ type: n.type, summary: n.summary })),
+        tentative: nodes.filter(n => n.confidence === "tentative").map(n => ({ type: n.type, summary: n.summary })),
+        untested: nodes.filter(n => n.outcome_score === null && ["heuristic", "mental_model", "assumption"].includes(n.type)).map(n => ({ type: n.type, summary: n.summary })),
+    }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// suggest_exploration
+// ---------------------------------------------------------------------------
+export async function toolSuggestExploration(currentContext) {
+    const vec = await embedOne(currentContext);
+    if (!vec)
+        return "Error: failed to embed context";
+    const hits = vectorSearch(vec, 40);
+    const nodeScores = new Map();
+    for (const h of hits) {
+        const nc = db.exec(`SELECT node_id FROM node_chunks WHERE chunk_id = '${h.chunkId}'`);
+        if (nc.length > 0) {
+            for (const row of nc[0].values)
+                nodeScores.set(row[0], Math.max(nodeScores.get(row[0]) || 0, h.score));
+        }
+    }
+    const candidates = [];
+    for (const [id, similarity] of nodeScores) {
+        const node = getNode(id);
+        if (!node)
+            continue;
+        const act = decayedActivation(node.activation, node.last_accessed, node.type);
+        if (act < 0.5 && similarity > 0.15) {
+            candidates.push({ id, type: node.type, summary: node.summary, activation: act, similarity });
+        }
+    }
+    candidates.sort((a, b) => b.similarity - a.similarity);
+    const typeSeen = new Set();
+    const diverse = [];
+    for (const c of candidates) {
+        if (!typeSeen.has(c.type) || diverse.length < 5) {
+            diverse.push(c);
+            typeSeen.add(c.type);
+        }
+        if (diverse.length >= 10)
+            break;
+    }
+    return JSON.stringify({ current_context: currentContext, forgotten_but_relevant: diverse }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// how_would_user_decide
+// ---------------------------------------------------------------------------
+export async function toolHowWouldUserDecide(context, options) {
+    const vec = await embedOne(context + (options ? " " + options : ""));
+    if (!vec)
+        return "Error: failed to embed context";
+    const hits = vectorSearch(vec, 40);
+    const nodeIds = new Set();
+    for (const h of hits) {
+        const nc = db.exec(`SELECT node_id FROM node_chunks WHERE chunk_id = '${h.chunkId}'`);
+        if (nc.length > 0)
+            nc[0].values.forEach((r) => nodeIds.add(r[0]));
+    }
+    const grouped = {};
+    for (const id of nodeIds) {
+        const node = getNode(id);
+        if (!node)
+            continue;
+        const t = node.type;
+        if (!["heuristic", "value", "mental_model", "preference", "assumption"].includes(t))
+            continue;
+        if (!grouped[t])
+            grouped[t] = [];
+        grouped[t].push({ summary: node.summary, confidence: node.confidence, activation: decayedActivation(node.activation, node.last_accessed, t) });
+    }
+    for (const t in grouped)
+        grouped[t].sort((a, b) => b.activation - a.activation);
+    return JSON.stringify({ context, options: options || null, reasoning_inputs: grouped }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// what_has_changed
+// ---------------------------------------------------------------------------
+export async function toolWhatHasChanged(domain) {
+    const vec = await embedOne(domain);
+    if (!vec)
+        return "Error: failed to embed domain";
+    const hits = vectorSearch(vec, 40);
+    const nodeIds = new Set();
+    for (const h of hits) {
+        const nc = db.exec(`SELECT node_id FROM node_chunks WHERE chunk_id = '${h.chunkId}'`);
+        if (nc.length > 0)
+            nc[0].values.forEach((r) => nodeIds.add(r[0]));
+    }
+    const nodes = [...nodeIds].map(id => getNode(id)).filter(Boolean).sort((a, b) => new Date(a.first_seen).getTime() - new Date(b.first_seen).getTime());
+    const idList = [...nodeIds].map(id => `'${id}'`).join(",") || "''";
+    const evolutions = queryNodes(`SELECT * FROM edges WHERE type = 'evolved_into' AND (source_node_id IN (${idList}) OR target_node_id IN (${idList}))`);
+    const outcomes = queryNodes(`SELECT * FROM outcomes WHERE node_id IN (${idList}) ORDER BY created_at DESC`);
+    return JSON.stringify({
+        domain,
+        timeline: nodes.map(n => ({ type: n.type, summary: n.summary, first_seen: n.first_seen, confidence: n.confidence })),
+        evolution_chains: evolutions,
+        outcomes: outcomes.slice(0, 10),
+    }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// correct
+// ---------------------------------------------------------------------------
+export async function toolCorrect(nodeId, newSummary, newConfidence) {
+    const existing = getNode(nodeId);
+    if (!existing)
+        return `Error: node ${nodeId} not found`;
+    db.run(`UPDATE nodes SET summary = ?, activation = MIN(activation + 2.0, 10.0), last_accessed = ? ${newConfidence ? ", confidence = ?" : ""} WHERE id = ?`, newConfidence ? [newSummary, now(), newConfidence, nodeId] : [newSummary, now(), nodeId]);
+    const oldChunks = db.exec(`SELECT chunk_id FROM node_chunks WHERE node_id = '${nodeId}'`);
+    const newChunkId = uuid();
+    // Insert new chunk FIRST so FK on superseded_by can reference it
+    const vec = await embedOne(newSummary);
+    if (vec) {
+        db.run("INSERT INTO chunks (id, text, source_type, epistemic_tag, confidence) VALUES (?, ?, 'capture', 'assertion', ?)", [newChunkId, newSummary, newConfidence || "strong"]);
+        db.run("INSERT INTO node_chunks (node_id, chunk_id) VALUES (?, ?)", [nodeId, newChunkId]);
+        db.run("INSERT INTO embeddings (chunk_id, vector, model, dims) VALUES (?, ?, ?, ?)", [newChunkId, JSON.stringify(vec), embeddingModel, embeddingDims]);
+        // Now supersede old chunks — new chunk exists so FK is satisfied
+        if (oldChunks.length > 0) {
+            for (const row of oldChunks[0].values) {
+                db.run(`UPDATE chunks SET superseded_by = ? WHERE id = ? AND superseded_by IS NULL`, [newChunkId, row[0]]);
+            }
+        }
+    }
+    persistDb();
+    return `Corrected node ${nodeId}. Old: "${existing.summary.slice(0, 60)}". New: "${newSummary.slice(0, 60)}".`;
+}
+// ---------------------------------------------------------------------------
+// record_outcome
+// ---------------------------------------------------------------------------
+export function toolRecordOutcome(nodeId, outcome, score) {
+    const existing = getNode(nodeId);
+    if (!existing)
+        return `Error: node ${nodeId} not found`;
+    db.run("INSERT INTO outcomes (id, node_id, outcome, score) VALUES (?, ?, ?, ?)", [uuid(), nodeId, outcome, score]);
+    const currentScore = existing.outcome_score ?? 0;
+    const newScore = currentScore === 0 ? score : (currentScore * 0.7 + score * 0.3);
+    db.run("UPDATE nodes SET outcome_score = ?, last_accessed = ? WHERE id = ?", [newScore, now(), nodeId]);
+    // Propagate to neighbors via edge-type-aware dampening (1-hop only)
+    const PROP_WEIGHTS = { supports: 0.3, contradicts: -0.2, depends_on: 0.15 };
+    const edgeRows = queryNodes(`SELECT id, type, source_node_id, target_node_id FROM edges WHERE source_node_id = '${nodeId}' OR target_node_id = '${nodeId}'`);
+    let propagated = 0;
+    for (const edge of edgeRows) {
+        const w = PROP_WEIGHTS[edge.type];
+        if (w === undefined)
+            continue;
+        const neighborId = edge.source_node_id === nodeId ? edge.target_node_id : edge.source_node_id;
+        db.run(`UPDATE nodes SET outcome_score = COALESCE(outcome_score, 0) * 0.7 + ? * 0.3, last_accessed = ? WHERE id = ?`, [score * w, now(), neighborId]);
+        propagated++;
+    }
+    // Auto-update confidence after 3+ outcomes
+    const countRows = db.exec(`SELECT COUNT(*) FROM outcomes WHERE node_id = '${nodeId}'`);
+    const outcomeCount = countRows.length > 0 ? countRows[0].values[0][0] : 0;
+    if (outcomeCount >= 3) {
+        if (newScore > 0.5)
+            db.run(`UPDATE nodes SET confidence = 'strong' WHERE id = ? AND confidence != 'strong'`, [nodeId]);
+        else if (newScore < -0.3)
+            db.run(`UPDATE nodes SET confidence = 'uncertain' WHERE id = ? AND confidence != 'uncertain'`, [nodeId]);
+    }
+    persistDb();
+    const propNote = propagated > 0 ? ` Propagated to ${propagated} neighbor(s).` : "";
+    return `Recorded outcome for "${existing.summary.slice(0, 50)}". Score: ${currentScore.toFixed(2)} -> ${newScore.toFixed(2)}.${propNote}`;
+}
+// ---------------------------------------------------------------------------
+// get_node
+// ---------------------------------------------------------------------------
+export function toolGetNode(nodeId) {
+    const node = getNode(nodeId);
+    if (!node)
+        return `Error: node ${nodeId} not found`;
+    const chunks = queryNodes(`SELECT c.* FROM chunks c JOIN node_chunks nc ON c.id = nc.chunk_id WHERE nc.node_id = '${nodeId}'`);
+    const edges = queryNodes(`SELECT * FROM edges WHERE source_node_id = '${nodeId}' OR target_node_id = '${nodeId}'`);
+    const outs = queryNodes(`SELECT * FROM outcomes WHERE node_id = '${nodeId}' ORDER BY created_at DESC`);
+    return JSON.stringify({ node, chunks, edges, outcomes: outs }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// get_neighbors
+// ---------------------------------------------------------------------------
+export function toolGetNeighbors(nodeId) {
+    const node = getNode(nodeId);
+    if (!node)
+        return `Error: node ${nodeId} not found`;
+    const edges = queryNodes(`SELECT * FROM edges WHERE source_node_id = '${nodeId}' OR target_node_id = '${nodeId}'`);
+    const neighborIds = new Set();
+    for (const e of edges) {
+        if (e.source_node_id !== nodeId)
+            neighborIds.add(e.source_node_id);
+        if (e.target_node_id !== nodeId)
+            neighborIds.add(e.target_node_id);
+    }
+    const neighbors = [...neighborIds].map(id => getNode(id)).filter(Boolean).map(n => ({ id: n.id, type: n.type, summary: n.summary, activation: n.activation }));
+    return JSON.stringify({ node: { id: node.id, type: node.type, summary: node.summary }, neighbors, edges }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// search_nodes
+// ---------------------------------------------------------------------------
+export function toolSearchNodes(query, nodeType) {
+    const words = query.split(/\s+/).filter(w => w.length > 2).map(w => `summary LIKE '%${w}%'`);
+    if (words.length === 0)
+        return JSON.stringify({ query, nodes: [] });
+    let sql = `SELECT * FROM nodes WHERE (${words.join(" OR ")})`;
+    if (nodeType && VALID_NODE_TYPES.has(nodeType))
+        sql += ` AND type = '${nodeType}'`;
+    sql += " ORDER BY activation DESC LIMIT 20";
+    const nodes = queryNodes(sql);
+    return JSON.stringify({ query, type_filter: nodeType || null, count: nodes.length, nodes }, null, 2);
+}
+// ---------------------------------------------------------------------------
+// merge_nodes
+// ---------------------------------------------------------------------------
+export function toolMergeNodes(keepId, mergeId) {
+    const keep = getNode(keepId);
+    const merge = getNode(mergeId);
+    if (!keep)
+        return `Error: node ${keepId} not found`;
+    if (!merge)
+        return `Error: node ${mergeId} not found`;
+    db.run(`UPDATE node_chunks SET node_id = ? WHERE node_id = ? AND chunk_id NOT IN (SELECT chunk_id FROM node_chunks WHERE node_id = ?)`, [keepId, mergeId, keepId]);
+    db.run(`DELETE FROM node_chunks WHERE node_id = ?`, [mergeId]);
+    db.run(`UPDATE edges SET source_node_id = ? WHERE source_node_id = ?`, [keepId, mergeId]);
+    db.run(`UPDATE edges SET target_node_id = ? WHERE target_node_id = ?`, [keepId, mergeId]);
+    db.run(`DELETE FROM edges WHERE source_node_id = target_node_id`);
+    db.run(`UPDATE outcomes SET node_id = ? WHERE node_id = ?`, [keepId, mergeId]);
+    db.run(`UPDATE nodes SET activation = ? WHERE id = ?`, [Math.max(keep.activation, merge.activation), keepId]);
+    db.run(`DELETE FROM nodes WHERE id = ?`, [mergeId]);
+    persistDb();
+    return `Merged "${merge.summary.slice(0, 50)}" into "${keep.summary.slice(0, 50)}".`;
+}
+// ---------------------------------------------------------------------------
+// archive_node
+// ---------------------------------------------------------------------------
+export function toolArchiveNode(nodeId) {
+    const existing = getNode(nodeId);
+    if (!existing)
+        return `Error: node ${nodeId} not found`;
+    db.run(`UPDATE nodes SET activation = 0.0, last_accessed = ? WHERE id = ?`, [now(), nodeId]);
+    persistDb();
+    return `Archived node ${nodeId} ("${existing.summary.slice(0, 50)}"). Will not appear in results.`;
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export type NodeType = "idea" | "question" | "project" | "heuristic" | "value" | "mental_model" | "assumption" | "tension" | "preference";
+export type EpistemicTag = "assertion" | "hypothesis" | "speculation" | "quoting" | "rejected";
+export type Confidence = "strong" | "tentative" | "uncertain";
+export type EdgeType = "supports" | "contradicts" | "evolved_into" | "inspired_by" | "depends_on" | "overrides" | "learned_from" | "scoped_by" | "rejected" | "belongs_to" | "derived_from";
+export declare const VALID_NODE_TYPES: Set<string>;
+export declare const VALID_EPISTEMIC_TAGS: Set<string>;
+export declare const VALID_CONFIDENCE: Set<string>;
+export declare const VALID_EDGE_TYPES: Set<string>;
+export declare const DECAY_RATES: Record<string, number>;
+export interface ExtractedPattern {
+    text: string;
+    type: string;
+    confidence: string;
+    epistemic: string;
+}
+export declare const DB_PATH: string;
+export declare const EMBEDDING_PROVIDER: string;
+export declare const VOYAGE_API_KEY: string | undefined;
+export declare const ANTHROPIC_API_KEY: string | undefined;
+export declare const OPENAI_API_KEY: string | undefined;
+export declare const OLLAMA_URL: string;

package/dist/types.js

@@ -0,0 +1,18 @@
+import * as path from "path";
+import * as os from "os";
+export const VALID_NODE_TYPES = new Set(["idea", "question", "project", "heuristic", "value", "mental_model", "assumption", "tension", "preference"]);
+export const VALID_EPISTEMIC_TAGS = new Set(["assertion", "hypothesis", "speculation", "quoting", "rejected"]);
+export const VALID_CONFIDENCE = new Set(["strong", "tentative", "uncertain"]);
+export const VALID_EDGE_TYPES = new Set(["supports", "contradicts", "evolved_into", "inspired_by", "depends_on", "overrides", "learned_from", "scoped_by", "rejected", "belongs_to", "derived_from"]);
+export const DECAY_RATES = {
+    value: 0.98, assumption: 0.98,
+    heuristic: 0.96, mental_model: 0.96, preference: 0.96, tension: 0.96,
+    idea: 0.93, question: 0.93, project: 0.93,
+};
+export const DB_PATH = process.env.THINKING_MCP_DB_PATH
+    || path.join(os.homedir(), ".thinking-mcp", "mind.db");
+export const EMBEDDING_PROVIDER = process.env.THINKING_MCP_EMBEDDING_PROVIDER || "voyage";
+export const VOYAGE_API_KEY = process.env.VOYAGE_API_KEY;
+export const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+export const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+export const OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";

package/package.json

@@ -0,0 +1 @@
+{"name":"@iflow-mcp/multimail-dev-thinking-mcp","version":"0.1.0","description":"MCP server that models how you think, not what you know","type":"module","bin":{"iflow-mcp_multimail-dev-thinking-mcp":"./dist/index.js"},"files":["dist"],"scripts":{"build":"tsc && chmod 755 dist/index.js","dev":"tsx src/index.ts","prepare":"npm run build"},"dependencies":{"@modelcontextprotocol/sdk":"^1.29.0","js-yaml":"^4.1.1","sql.js":"^1.14.0","zod":"^3.25.0"},"devDependencies":{"@types/js-yaml":"^4.0.9","@types/node":"^22.0.0","tsx":"^4.0.0","typescript":"^5.8.0"},"keywords":["mcp","cognitive","knowledge-graph","thinking","mental-model"],"license":"MIT","repository":{"type":"git","url":"https://github.com/multimail-dev/thinking-mcp"},"homepage":"https://multimail.dev","publishConfig":{"access":"public"},"engines":{"node":">=20"}}