@feelingmindful/thinking-graph 1.2.0 → 1.4.0

package/dist/compat/sequential.d.ts

@@ -1,20 +1,15 @@
 import { z } from 'zod';
 import type { ThinkingGraph } from '../engine/graph.js';
-/**
- * Backward compatibility shim for the original `sequentialthinking` tool.
- * Maps the old API (thought, thoughtNumber, totalThoughts, nextThoughtNeeded)
- * to the new `think` tool, preserving the original response format.
- */
 export declare const sequentialSchema: z.ZodObject<{
     thought: z.ZodString;
     thoughtNumber: z.ZodNumber;
     totalThoughts: z.ZodNumber;
-    nextThoughtNeeded: z.ZodBoolean;
-    isRevision: z.ZodOptional<z.ZodBoolean>;
+    nextThoughtNeeded: z.ZodEffects<z.ZodBoolean, boolean, unknown>;
+    isRevision: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
     revisesThought: z.ZodOptional<z.ZodNumber>;
     branchFromThought: z.ZodOptional<z.ZodNumber>;
     branchId: z.ZodOptional<z.ZodString>;
-    needsMoreThoughts: z.ZodOptional<z.ZodBoolean>;
+    needsMoreThoughts: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
 }, "strip", z.ZodTypeAny, {
     thought: string;
     thoughtNumber: number;
@@ -29,12 +24,12 @@ export declare const sequentialSchema: z.ZodObject<{
     thought: string;
     thoughtNumber: number;
     totalThoughts: number;
-    nextThoughtNeeded: boolean;
     branchId?: string | undefined;
-    isRevision?: boolean | undefined;
+    isRevision?: unknown;
     revisesThought?: number | undefined;
+    nextThoughtNeeded?: unknown;
     branchFromThought?: number | undefined;
-    needsMoreThoughts?: boolean | undefined;
+    needsMoreThoughts?: unknown;
 }>;
 export type SequentialInput = z.infer<typeof sequentialSchema>;
 export declare function compatHandler(graph: ThinkingGraph, input: SequentialInput): Promise<{

package/dist/compat/sequential.js

@@ -4,16 +4,17 @@ import { z } from 'zod';
  * Maps the old API (thought, thoughtNumber, totalThoughts, nextThoughtNeeded)
  * to the new `think` tool, preserving the original response format.
  */
+const coerceBool = z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean());
 export const sequentialSchema = z.object({
     thought: z.string().describe('The current thinking step'),
-    thoughtNumber: z.number().int().min(1).describe('Current thought number'),
-    totalThoughts: z.number().int().min(1).describe('Estimated total thoughts'),
-    nextThoughtNeeded: z.boolean().describe('Whether another step is needed'),
-    isRevision: z.boolean().optional(),
-    revisesThought: z.number().int().min(1).optional(),
-    branchFromThought: z.number().int().min(1).optional(),
+    thoughtNumber: z.coerce.number().int().min(1).describe('Current thought number'),
+    totalThoughts: z.coerce.number().int().min(1).describe('Estimated total thoughts'),
+    nextThoughtNeeded: coerceBool.describe('Whether another step is needed'),
+    isRevision: coerceBool.optional(),
+    revisesThought: z.coerce.number().int().min(1).optional(),
+    branchFromThought: z.coerce.number().int().min(1).optional(),
     branchId: z.string().optional(),
-    needsMoreThoughts: z.boolean().optional(),
+    needsMoreThoughts: coerceBool.optional(),
 });
 export async function compatHandler(graph, input) {
     const session = await graph.getCurrentSession();

package/dist/index.js

@@ -9,7 +9,7 @@ import { relateSchema, relateHandler } from './tools/relate.js';
 import { recallSchema, recallHandler } from './tools/recall.js';
 import { learnSchema, learnHandler } from './tools/learn.js';
 import { exportSchema, exportHandler } from './tools/export.js';
-import { sequentialSchema, compatHandler } from './compat/sequential.js';
+// Legacy compat shim removed — use `think` tool directly
 // ─── Storage setup ───────────────────────────────────────
 const memoryOnly = process.env.THINKING_GRAPH_MEMORY_ONLY === 'true';
 const storage = memoryOnly
@@ -30,8 +30,6 @@ server.tool('relate', 'Create a typed, directional relationship between two node
 server.tool('recall', 'Query the thinking graph — search by text, filter by type, traverse relationships, or search across projects.', recallSchema.shape, async (input) => recallHandler(graph, input));
 server.tool('learn', 'Store durable knowledge — code facts, tech debt, insights, principles. Deduplicates similar content.', learnSchema.shape, async (input) => learnHandler(graph, input));
 server.tool('export', 'Export the thinking graph as JSON or a human-readable markdown summary.', exportSchema.shape, async (input) => exportHandler(graph, input));
-// Backward compat: register the original tool name
-server.tool('sequentialthinking', 'Record a sequential thinking step (backward compatible with @modelcontextprotocol/server-sequential-thinking).', sequentialSchema.shape, async (input) => compatHandler(graph, input));
 // ─── Startup ─────────────────────────────────────────────
 async function main() {
     await storage.initialize();

package/dist/storage/sqlite.d.ts

@@ -9,6 +9,10 @@ export declare class SQLiteAdapter implements StorageAdapter {
     constructor(opts: SQLiteAdapterOpts);
     initialize(): Promise<void>;
     close(): Promise<void>;
+    private persist;
+    private runSql;
+    private getSingle;
+    private getAll;
     insertNode(node: Node): Promise<void>;
     getNode(id: string): Promise<Node | null>;
     queryNodes(query: NodeQuery): Promise<PaginatedResult<Node>>;

package/dist/storage/sqlite.js

@@ -1,10 +1,17 @@
-import Database from 'better-sqlite3';
-import { readFileSync } from 'fs';
+import initSqlJs from 'sql.js';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { mkdirSync } from 'fs';
 import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const MIGRATION_PATH = join(__dirname, '../../migrations/001-initial.sql');
+// Cache the WASM module so multiple instances don't re-initialize Emscripten
+let sqlJsPromise = null;
+function getSqlJs() {
+    if (!sqlJsPromise)
+        sqlJsPromise = initSqlJs();
+    return sqlJsPromise;
+}
 export class SQLiteAdapter {
     db;
     dbPath;
@@ -12,30 +19,85 @@ export class SQLiteAdapter {
         this.dbPath = opts.dbPath;
     }
     async initialize() {
-        // Ensure parent directory exists
         const dir = dirname(this.dbPath);
         mkdirSync(dir, { recursive: true });
-        this.db = new Database(this.dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.pragma('foreign_keys = ON');
-        // Run migration
+        const SQL = await getSqlJs();
+        if (existsSync(this.dbPath)) {
+            const fileBuffer = readFileSync(this.dbPath);
+            this.db = new SQL.Database(new Uint8Array(fileBuffer));
+        }
+        else {
+            this.db = new SQL.Database();
+        }
+        this.db.run('PRAGMA foreign_keys = ON');
+        // Run migration (multi-statement)
         const sql = readFileSync(MIGRATION_PATH, 'utf-8');
         this.db.exec(sql);
+        this.persist();
     }
     async close() {
+        this.persist();
         this.db.close();
     }
+    persist() {
+        const data = this.db.export();
+        const buffer = Buffer.from(data);
+        writeFileSync(this.dbPath, buffer);
+    }
+    // ─── Helpers ──────────────────────────────────────────
+    runSql(sql, params = []) {
+        this.db.run(sql, params);
+        this.persist();
+    }
+    getSingle(sql, params = []) {
+        const stmt = this.db.prepare(sql);
+        stmt.bind(params);
+        if (stmt.step()) {
+            const columns = stmt.getColumnNames();
+            const values = stmt.get();
+            stmt.free();
+            const row = {};
+            for (let i = 0; i < columns.length; i++) {
+                row[columns[i]] = values[i];
+            }
+            return row;
+        }
+        stmt.free();
+        return undefined;
+    }
+    getAll(sql, params = []) {
+        const stmt = this.db.prepare(sql);
+        stmt.bind(params);
+        const rows = [];
+        while (stmt.step()) {
+            const columns = stmt.getColumnNames();
+            const values = stmt.get();
+            const row = {};
+            for (let i = 0; i < columns.length; i++) {
+                row[columns[i]] = values[i];
+            }
+            rows.push(row);
+        }
+        stmt.free();
+        return rows;
+    }
     // ─── Nodes ─────────────────────────────────────────────
     async insertNode(node) {
-        this.db.prepare(`
+        this.runSql(`
       INSERT INTO nodes (id, type, content, session_id, project_id, metadata,
         created_at, updated_at, thought_number, total_thoughts, branch_id,
         is_revision, revises_thought)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(node.id, node.type, node.content, node.sessionId, node.projectId ?? null, JSON.stringify(node.metadata), node.createdAt, node.updatedAt, node.thoughtNumber ?? null, node.totalThoughts ?? null, node.branchId ?? null, node.isRevision ? 1 : 0, node.revisesThought ?? null);
+    `, [
+            node.id, node.type, node.content, node.sessionId, node.projectId ?? null,
+            JSON.stringify(node.metadata), node.createdAt, node.updatedAt,
+            node.thoughtNumber ?? null, node.totalThoughts ?? null,
+            node.branchId ?? null, node.isRevision ? 1 : 0,
+            node.revisesThought ?? null,
+        ]);
     }
     async getNode(id) {
-        const row = this.db.prepare('SELECT * FROM nodes WHERE id = ?').get(id);
+        const row = this.getSingle('SELECT * FROM nodes WHERE id = ?', [id]);
         return row ? this.rowToNode(row) : null;
     }
     async queryNodes(query) {
@@ -59,16 +121,15 @@ export class SQLiteAdapter {
             params.push(query.since);
         }
         if (query.query) {
-            // Use FTS for text search
-            conditions.push('rowid IN (SELECT rowid FROM nodes_fts WHERE nodes_fts MATCH ?)');
-            params.push(query.query);
+            conditions.push('content LIKE ?');
+            params.push(`%${query.query}%`);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const countRow = this.db.prepare(`SELECT COUNT(*) as cnt FROM nodes ${where}`).get(...params);
+        const countRow = this.getSingle(`SELECT COUNT(*) as cnt FROM nodes ${where}`, params);
         const totalCount = countRow.cnt;
         const limit = query.limit ?? 20;
         const offset = query.offset ?? 0;
-        const rows = this.db.prepare(`SELECT * FROM nodes ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        const rows = this.getAll(`SELECT * FROM nodes ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`, [...params, limit, offset]);
         return {
             items: rows.map(r => this.rowToNode(r)),
             totalCount,
@@ -76,22 +137,24 @@ export class SQLiteAdapter {
         };
     }
     async searchContent(text, limit = 20) {
-        const rows = this.db.prepare(`
-      SELECT n.* FROM nodes_fts fts
-      JOIN nodes n ON n.rowid = fts.rowid
-      WHERE nodes_fts MATCH ?
-      ORDER BY rank
+        const rows = this.getAll(`
+      SELECT * FROM nodes
+      WHERE content LIKE ?
+      ORDER BY created_at DESC
       LIMIT ?
-    `).all(text, limit);
+    `, [`%${text}%`, limit]);
         return rows.map(r => this.rowToNode(r));
     }
     // ─── Edges ─────────────────────────────────────────────
     async insertEdge(edge) {
         try {
-            this.db.prepare(`
+            this.runSql(`
         INSERT INTO edges (id, source_id, target_id, type, weight, reasoning, created_at)
         VALUES (?, ?, ?, ?, ?, ?, ?)
-      `).run(edge.id, edge.sourceId, edge.targetId, edge.type, edge.weight, edge.reasoning ?? null, edge.createdAt);
+      `, [
+                edge.id, edge.sourceId, edge.targetId, edge.type,
+                edge.weight, edge.reasoning ?? null, edge.createdAt,
+            ]);
             return true;
         }
         catch (err) {
@@ -106,7 +169,7 @@ export class SQLiteAdapter {
             ? 'SELECT * FROM edges WHERE source_id = ? AND type = ?'
             : 'SELECT * FROM edges WHERE source_id = ?';
         const params = type ? [nodeId, type] : [nodeId];
-        const rows = this.db.prepare(sql).all(...params);
+        const rows = this.getAll(sql, params);
         return rows.map(r => this.rowToEdge(r));
     }
     async getEdgesTo(nodeId, type) {
@@ -114,11 +177,11 @@ export class SQLiteAdapter {
             ? 'SELECT * FROM edges WHERE target_id = ? AND type = ?'
             : 'SELECT * FROM edges WHERE target_id = ?';
         const params = type ? [nodeId, type] : [nodeId];
-        const rows = this.db.prepare(sql).all(...params);
+        const rows = this.getAll(sql, params);
         return rows.map(r => this.rowToEdge(r));
     }
     async traverseEdges(startId, type, maxDepth) {
-        const rows = this.db.prepare(`
+        const rows = this.getAll(`
       WITH RECURSIVE chain(id, depth) AS (
         SELECT target_id, 1
         FROM edges
@@ -132,18 +195,21 @@ export class SQLiteAdapter {
       SELECT DISTINCT n.* FROM nodes n
       JOIN chain c ON n.id = c.id
       ORDER BY c.depth
-    `).all(startId, type, type, maxDepth);
+    `, [startId, type, type, maxDepth]);
         return rows.map(r => this.rowToNode(r));
     }
     // ─── Sessions ──────────────────────────────────────────
     async insertSession(session) {
-        this.db.prepare(`
+        this.runSql(`
       INSERT INTO sessions (id, project_id, project_path, description, started_at, last_active)
       VALUES (?, ?, ?, ?, ?, ?)
-    `).run(session.id, session.projectId ?? null, session.projectPath ?? null, session.description ?? null, session.startedAt, session.lastActiveAt);
+    `, [
+            session.id, session.projectId ?? null, session.projectPath ?? null,
+            session.description ?? null, session.startedAt, session.lastActiveAt,
+        ]);
     }
     async getSession(id) {
-        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+        const row = this.getSingle('SELECT * FROM sessions WHERE id = ?', [id]);
         return row ? this.rowToSession(row) : null;
     }
     async updateSession(id, fields) {
@@ -159,16 +225,20 @@ export class SQLiteAdapter {
         }
         if (sets.length > 0) {
             params.push(id);
-            this.db.prepare(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+            this.runSql(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`, params);
         }
     }
     // ─── Skill Registry ───────────────────────────────────
     async insertSkill(entry) {
-        this.db.prepare(`
+        this.runSql(`
       INSERT OR IGNORE INTO skill_registry
         (id, plugin_name, skill_name, verb, invocation, areas, detects, produces, invokes, platform)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(entry.id, entry.pluginName, entry.skillName, entry.verb ?? null, entry.invocation, JSON.stringify(entry.areas), JSON.stringify(entry.detects), JSON.stringify(entry.produces), JSON.stringify(entry.invokes), entry.platform ?? null);
+    `, [
+            entry.id, entry.pluginName, entry.skillName, entry.verb ?? null,
+            entry.invocation, JSON.stringify(entry.areas), JSON.stringify(entry.detects),
+            JSON.stringify(entry.produces), JSON.stringify(entry.invokes), entry.platform ?? null,
+        ]);
     }
     async querySkills(filter) {
         const conditions = [];
@@ -194,7 +264,7 @@ export class SQLiteAdapter {
             params.push(filter.platform);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const rows = this.db.prepare(`SELECT * FROM skill_registry ${where}`).all(...params);
+        const rows = this.getAll(`SELECT * FROM skill_registry ${where}`, params);
         return rows.map(r => ({
             id: r.id,
             pluginName: r.plugin_name,
@@ -226,18 +296,18 @@ export class SQLiteAdapter {
             params.push(...types);
         }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const nodeRows = this.db.prepare(`SELECT * FROM nodes ${where}`).all(...params);
+        const nodeRows = this.getAll(`SELECT * FROM nodes ${where}`, params);
         const nodes = nodeRows.map(r => this.rowToNode(r));
         let edges = [];
         if (opts?.includeEdges !== false) {
             const nodeIds = nodes.map(n => n.id);
             if (nodeIds.length > 0) {
                 const placeholders = nodeIds.map(() => '?').join(',');
-                const edgeRows = this.db.prepare(`SELECT * FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`).all(...nodeIds, ...nodeIds);
+                const edgeRows = this.getAll(`SELECT * FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`, [...nodeIds, ...nodeIds]);
                 edges = edgeRows.map(r => this.rowToEdge(r));
             }
         }
-        const sessionRows = this.db.prepare('SELECT * FROM sessions').all();
+        const sessionRows = this.getAll('SELECT * FROM sessions');
         return {
             exportedAt: new Date().toISOString(),
             nodeCount: nodes.length,
@@ -250,15 +320,15 @@ export class SQLiteAdapter {
     // ─── Stats ─────────────────────────────────────────────
     async getStats() {
         const nodesByType = {};
-        const ntRows = this.db.prepare('SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type').all();
+        const ntRows = this.getAll('SELECT type, COUNT(*) as cnt FROM nodes GROUP BY type');
         for (const r of ntRows)
             nodesByType[r.type] = r.cnt;
         const edgesByType = {};
-        const etRows = this.db.prepare('SELECT type, COUNT(*) as cnt FROM edges GROUP BY type').all();
+        const etRows = this.getAll('SELECT type, COUNT(*) as cnt FROM edges GROUP BY type');
         for (const r of etRows)
             edgesByType[r.type] = r.cnt;
-        const totalNodes = this.db.prepare('SELECT COUNT(*) as cnt FROM nodes').get().cnt;
-        const totalEdges = this.db.prepare('SELECT COUNT(*) as cnt FROM edges').get().cnt;
+        const totalNodes = this.getSingle('SELECT COUNT(*) as cnt FROM nodes').cnt;
+        const totalEdges = this.getSingle('SELECT COUNT(*) as cnt FROM edges').cnt;
         return {
             totalNodes,
             totalEdges,

package/dist/tools/export.d.ts

@@ -5,7 +5,7 @@ export declare const exportSchema: z.ZodObject<{
     sessionId: z.ZodOptional<z.ZodString>;
     projectId: z.ZodOptional<z.ZodString>;
     type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, z.ZodArray<z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, "many">]>>;
-    includeEdges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeEdges: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>>;
     outputPath: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     format: "json" | "summary";
@@ -19,7 +19,7 @@ export declare const exportSchema: z.ZodObject<{
     type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | ("thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research")[] | undefined;
     sessionId?: string | undefined;
     projectId?: string | undefined;
-    includeEdges?: boolean | undefined;
+    includeEdges?: unknown;
     outputPath?: string | undefined;
 }>;
 export type ExportInput = z.infer<typeof exportSchema>;

package/dist/tools/export.js

@@ -6,7 +6,7 @@ export const exportSchema = z.object({
     sessionId: z.string().optional(),
     projectId: z.string().optional(),
     type: z.union([z.enum(NODE_TYPES), z.array(z.enum(NODE_TYPES))]).optional(),
-    includeEdges: z.boolean().optional().default(true),
+    includeEdges: z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean()).optional().default(true),
     outputPath: z.string().optional().describe('Write to file'),
 });
 export async function exportHandler(graph, input) {

package/dist/tools/learn.js

@@ -5,7 +5,7 @@ export const learnSchema = z.object({
     type: z.enum(NODE_TYPES).describe('Node type'),
     projectId: z.string().optional(),
     filePath: z.string().optional().describe('For code_facts'),
-    lineRange: z.tuple([z.number(), z.number()]).optional().describe('Line range [start, end]'),
+    lineRange: z.tuple([z.coerce.number(), z.coerce.number()]).optional().describe('Line range [start, end]'),
     severity: z.enum(['critical', 'high', 'medium', 'low']).optional().describe('For tech_debt'),
     effort: z.string().optional().describe('Estimated fix effort'),
     impact: z.string().optional().describe('What breaks if unfixed'),

package/dist/tools/recall.d.ts

@@ -5,7 +5,7 @@ export declare const recallSchema: z.ZodObject<{
     type: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, z.ZodArray<z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>, "many">]>>;
     sessionId: z.ZodOptional<z.ZodString>;
     projectId: z.ZodOptional<z.ZodString>;
-    crossProject: z.ZodOptional<z.ZodBoolean>;
+    crossProject: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
     relatedTo: z.ZodOptional<z.ZodString>;
     edgeType: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>, z.ZodArray<z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>, "many">]>>;
     direction: z.ZodOptional<z.ZodEnum<["outgoing", "incoming", "both"]>>;
@@ -34,7 +34,7 @@ export declare const recallSchema: z.ZodObject<{
     projectId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
     query?: string | undefined;
-    crossProject?: boolean | undefined;
+    crossProject?: unknown;
     relatedTo?: string | undefined;
     edgeType?: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by" | ("depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by")[] | undefined;
     direction?: "outgoing" | "incoming" | "both" | undefined;

package/dist/tools/recall.js

@@ -1,19 +1,20 @@
 import { z } from 'zod';
 import { NODE_TYPES, EDGE_TYPES } from '../engine/types.js';
+const coerceBool = z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean());
 export const recallSchema = z.object({
     query: z.string().optional().describe('Full-text search'),
     type: z.union([z.enum(NODE_TYPES), z.array(z.enum(NODE_TYPES))]).optional(),
     sessionId: z.string().optional(),
     projectId: z.string().optional(),
-    crossProject: z.boolean().optional().describe('Search across all projects'),
+    crossProject: coerceBool.optional().describe('Search across all projects'),
     relatedTo: z.string().optional().describe('Find nodes connected to this ID'),
     edgeType: z.union([z.enum(EDGE_TYPES), z.array(z.enum(EDGE_TYPES))]).optional(),
     direction: z.enum(['outgoing', 'incoming', 'both']).optional(),
-    depth: z.number().int().min(1).optional().describe('Traversal depth'),
+    depth: z.coerce.number().int().min(1).optional().describe('Traversal depth'),
     since: z.string().optional().describe('ISO timestamp'),
     metadata: z.record(z.unknown()).optional(),
-    limit: z.number().int().min(1).max(100).optional(),
-    offset: z.number().int().min(0).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    offset: z.coerce.number().int().min(0).optional(),
 });
 export async function recallHandler(graph, input) {
     // If relatedTo is specified, use graph traversal

package/dist/tools/relate.d.ts

@@ -6,7 +6,7 @@ export declare const relateSchema: z.ZodObject<{
     type: z.ZodEnum<["depends_on", "contradicts", "supports", "refines", "supersedes", "similar_to", "located_in", "violates", "addresses", "detected_by", "invoked_by"]>;
     weight: z.ZodOptional<z.ZodNumber>;
     reasoning: z.ZodOptional<z.ZodString>;
-    bidirectional: z.ZodOptional<z.ZodBoolean>;
+    bidirectional: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
 }, "strip", z.ZodTypeAny, {
     type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
     sourceId: string;
@@ -20,7 +20,7 @@ export declare const relateSchema: z.ZodObject<{
     targetId: string;
     weight?: number | undefined;
     reasoning?: string | undefined;
-    bidirectional?: boolean | undefined;
+    bidirectional?: unknown;
 }>;
 export type RelateInput = z.infer<typeof relateSchema>;
 export declare function relateHandler(graph: ThinkingGraph, input: RelateInput): Promise<{

package/dist/tools/relate.js

@@ -1,12 +1,13 @@
 import { z } from 'zod';
 import { EDGE_TYPES } from '../engine/types.js';
+const coerceBool = z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean());
 export const relateSchema = z.object({
     sourceId: z.string().describe('Node ID (prefix with "?" for content search)'),
     targetId: z.string().describe('Node ID, content search, or principle name'),
     type: z.enum(EDGE_TYPES).describe('Relationship type'),
-    weight: z.number().min(0).max(1).optional().describe('Confidence 0-1'),
+    weight: z.coerce.number().min(0).max(1).optional().describe('Confidence 0-1'),
     reasoning: z.string().optional().describe('Why this relationship exists'),
-    bidirectional: z.boolean().optional().describe('Create reverse edge too'),
+    bidirectional: coerceBool.optional().describe('Create reverse edge too'),
 });
 async function resolveId(graph, id) {
     if (id.startsWith('?')) {

package/dist/tools/think.d.ts

@@ -5,7 +5,7 @@ export declare const thinkSchema: z.ZodObject<{
     type: z.ZodDefault<z.ZodEnum<["thought", "decision", "insight", "code_fact", "assumption", "detection", "tech_debt", "principle", "pattern", "skill_result", "research"]>>;
     thoughtNumber: z.ZodNumber;
     totalThoughts: z.ZodNumber;
-    nextThoughtNeeded: z.ZodBoolean;
+    nextThoughtNeeded: z.ZodEffects<z.ZodBoolean, boolean, unknown>;
     sessionId: z.ZodOptional<z.ZodString>;
     projectId: z.ZodOptional<z.ZodString>;
     relates: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -22,11 +22,11 @@ export declare const thinkSchema: z.ZodObject<{
         reasoning?: string | undefined;
     }>, "many">>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    isRevision: z.ZodOptional<z.ZodBoolean>;
+    isRevision: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
     revisesThought: z.ZodOptional<z.ZodNumber>;
     branchFromThought: z.ZodOptional<z.ZodNumber>;
     branchId: z.ZodOptional<z.ZodString>;
-    needsMoreThoughts: z.ZodOptional<z.ZodBoolean>;
+    needsMoreThoughts: z.ZodOptional<z.ZodEffects<z.ZodBoolean, boolean, unknown>>;
 }, "strip", z.ZodTypeAny, {
     thought: string;
     type: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research";
@@ -50,21 +50,21 @@ export declare const thinkSchema: z.ZodObject<{
     thought: string;
     thoughtNumber: number;
     totalThoughts: number;
-    nextThoughtNeeded: boolean;
     type?: "thought" | "decision" | "insight" | "code_fact" | "assumption" | "detection" | "tech_debt" | "principle" | "pattern" | "skill_result" | "research" | undefined;
     sessionId?: string | undefined;
     projectId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
     branchId?: string | undefined;
-    isRevision?: boolean | undefined;
+    isRevision?: unknown;
     revisesThought?: number | undefined;
+    nextThoughtNeeded?: unknown;
     relates?: {
         type: "depends_on" | "contradicts" | "supports" | "refines" | "supersedes" | "similar_to" | "located_in" | "violates" | "addresses" | "detected_by" | "invoked_by";
         targetId: string;
         reasoning?: string | undefined;
     }[] | undefined;
     branchFromThought?: number | undefined;
-    needsMoreThoughts?: boolean | undefined;
+    needsMoreThoughts?: unknown;
 }>;
 export type ThinkInput = z.infer<typeof thinkSchema>;
 export declare function thinkHandler(graph: ThinkingGraph, input: ThinkInput): Promise<{

package/dist/tools/think.js

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import { NODE_TYPES, EDGE_TYPES } from '../engine/types.js';
+const coerceBool = z.preprocess((v) => (v === 'true' ? true : v === 'false' ? false : v), z.boolean());
 export const thinkSchema = z.object({
     thought: z.string().describe('The reasoning content'),
     type: z.enum(NODE_TYPES).default('thought').describe('Node type'),
-    thoughtNumber: z.number().int().min(1).describe('Current thought number'),
-    totalThoughts: z.number().int().min(1).describe('Estimated total thoughts'),
-    nextThoughtNeeded: z.boolean().describe('Whether another step is needed'),
+    thoughtNumber: z.coerce.number().int().min(1).describe('Current thought number'),
+    totalThoughts: z.coerce.number().int().min(1).describe('Estimated total thoughts'),
+    nextThoughtNeeded: coerceBool.describe('Whether another step is needed'),
     sessionId: z.string().optional().describe('Session ID (auto-generated if omitted)'),
     projectId: z.string().optional().describe('Project ID (detected from cwd if omitted)'),
     relates: z.array(z.object({
@@ -15,11 +16,11 @@ export const thinkSchema = z.object({
     })).optional().describe('Inline relationships'),
     metadata: z.record(z.unknown()).optional().describe('Flexible metadata'),
     // Backward compat
-    isRevision: z.boolean().optional(),
-    revisesThought: z.number().int().min(1).optional(),
-    branchFromThought: z.number().int().min(1).optional(),
+    isRevision: coerceBool.optional(),
+    revisesThought: z.coerce.number().int().min(1).optional(),
+    branchFromThought: z.coerce.number().int().min(1).optional(),
     branchId: z.string().optional(),
-    needsMoreThoughts: z.boolean().optional(),
+    needsMoreThoughts: coerceBool.optional(),
 });
 export async function thinkHandler(graph, input) {
     const session = input.sessionId

package/migrations/001-initial.sql

@@ -1,7 +1,6 @@
 -- Thinking Graph Schema v1
--- Sessions, Nodes (with FTS5), Edges, Skill Registry
+-- Sessions, Nodes, Edges, Skill Registry
 
-PRAGMA journal_mode = WAL;
 PRAGMA foreign_keys = ON;
 
 -- ─── Sessions ────────────────────────────────────────────
@@ -47,27 +46,6 @@ CREATE INDEX IF NOT EXISTS idx_nodes_project ON nodes(project_id);
 CREATE INDEX IF NOT EXISTS idx_nodes_branch  ON nodes(branch_id);
 CREATE INDEX IF NOT EXISTS idx_nodes_created ON nodes(created_at);
 
--- Full-text search
-CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
-  content,
-  content='nodes',
-  content_rowid='rowid'
-);
-
--- Keep FTS in sync
-CREATE TRIGGER IF NOT EXISTS nodes_ai AFTER INSERT ON nodes BEGIN
-  INSERT INTO nodes_fts(rowid, content) VALUES (new.rowid, new.content);
-END;
-
-CREATE TRIGGER IF NOT EXISTS nodes_au AFTER UPDATE ON nodes BEGIN
-  INSERT INTO nodes_fts(nodes_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
-  INSERT INTO nodes_fts(rowid, content) VALUES (new.rowid, new.content);
-END;
-
-CREATE TRIGGER IF NOT EXISTS nodes_ad AFTER DELETE ON nodes BEGIN
-  INSERT INTO nodes_fts(nodes_fts, rowid, content) VALUES ('delete', old.rowid, old.content);
-END;
-
 -- ─── Edges ───────────────────────────────────────────────
 
 CREATE TABLE IF NOT EXISTS edges (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",
@@ -31,14 +31,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "better-sqlite3": "^11.0.0",
-    "zod": "^3.23.0",
-    "uuid": "^10.0.0"
+    "sql.js": "^1.12.0",
+    "uuid": "^10.0.0",
+    "zod": "^3.23.0"
   },
   "devDependencies": {
-    "vitest": "^3.0.0",
+    "@types/node": "^25.5.0",
+    "@types/uuid": "^10.0.0",
     "typescript": "^5.5.0",
-    "@types/better-sqlite3": "^7.6.0",
-    "@types/uuid": "^10.0.0"
+    "vitest": "^3.0.0"
   }
 }

package/seeds/skill-registry.json

@@ -90,74 +90,74 @@
     "produces": [], "invokes": ["premium-android:research", "premium-android:init", "premium-android:configure", "premium-android:refactor", "premium-android:create", "premium-core:growth", "premium-core:humanize", "premium-android:audit"], "platform": "android"
   },
   {
-    "id": "nextjs-research", "pluginName": "premium-nextjs", "skillName": "research", "verb": "research",
-    "invocation": "/premium-nextjs:research", "areas": [], "detects": [],
+    "id": "nextjs-research", "pluginName": "premium-web", "skillName": "nextjs", "verb": "research",
+    "invocation": "/premium-web:nextjs", "areas": [], "detects": [],
     "produces": ["research"], "invokes": ["premium-core:research"], "platform": "nextjs"
   },
   {
-    "id": "nextjs-init", "pluginName": "premium-nextjs", "skillName": "init", "verb": "init",
-    "invocation": "/premium-nextjs:init", "areas": ["infra", "design-tokens", "monetization", "observability"], "detects": ["missing"],
+    "id": "nextjs-init", "pluginName": "premium-web", "skillName": "nextjs", "verb": "init",
+    "invocation": "/premium-web:nextjs", "areas": ["infra", "design-tokens", "monetization", "observability"], "detects": ["missing"],
     "produces": ["code_fact", "decision"], "invokes": [], "platform": "nextjs"
   },
   {
-    "id": "nextjs-configure", "pluginName": "premium-nextjs", "skillName": "configure", "verb": "configure",
-    "invocation": "/premium-nextjs:configure", "areas": ["infra", "security", "observability"], "detects": ["needs-work"],
+    "id": "nextjs-configure", "pluginName": "premium-web", "skillName": "nextjs", "verb": "configure",
+    "invocation": "/premium-web:nextjs", "areas": ["infra", "security", "observability"], "detects": ["needs-work"],
     "produces": ["code_fact"], "invokes": [], "platform": "nextjs"
   },
   {
-    "id": "nextjs-refactor", "pluginName": "premium-nextjs", "skillName": "refactor", "verb": "refactor",
-    "invocation": "/premium-nextjs:refactor", "areas": ["architecture", "design-tokens", "icons", "copy"], "detects": ["needs-work"],
+    "id": "nextjs-refactor", "pluginName": "premium-web", "skillName": "nextjs", "verb": "refactor",
+    "invocation": "/premium-web:nextjs", "areas": ["architecture", "design-tokens", "icons", "copy"], "detects": ["needs-work"],
     "produces": ["tech_debt", "code_fact", "decision"], "invokes": ["premium-core:humanize"], "platform": "nextjs"
   },
   {
-    "id": "nextjs-create", "pluginName": "premium-nextjs", "skillName": "create", "verb": "create",
-    "invocation": "/premium-nextjs:create", "areas": ["design-tokens", "animations", "typography", "icons", "monetization"], "detects": ["missing"],
+    "id": "nextjs-create", "pluginName": "premium-web", "skillName": "nextjs", "verb": "create",
+    "invocation": "/premium-web:nextjs", "areas": ["design-tokens", "animations", "typography", "icons", "monetization"], "detects": ["missing"],
     "produces": ["code_fact", "decision"], "invokes": [], "platform": "nextjs"
   },
   {
-    "id": "nextjs-audit", "pluginName": "premium-nextjs", "skillName": "audit", "verb": "audit",
-    "invocation": "/premium-nextjs:audit", "areas": ["architecture", "design-tokens", "typography", "icons", "copy", "monetization", "security", "observability", "seo"], "detects": ["missing", "needs-work", "good"],
+    "id": "nextjs-audit", "pluginName": "premium-web", "skillName": "nextjs", "verb": "audit",
+    "invocation": "/premium-web:nextjs", "areas": ["architecture", "design-tokens", "typography", "icons", "copy", "monetization", "security", "observability", "seo"], "detects": ["missing", "needs-work", "good"],
     "produces": ["detection", "tech_debt"], "invokes": ["premium-core:audit"], "platform": "nextjs"
   },
   {
-    "id": "nextjs-full", "pluginName": "premium-nextjs", "skillName": "full", "verb": "full",
-    "invocation": "/premium-nextjs:full", "areas": [], "detects": [],
-    "produces": [], "invokes": ["premium-nextjs:research", "premium-nextjs:init", "premium-nextjs:configure", "premium-nextjs:refactor", "premium-nextjs:create", "premium-core:growth", "premium-core:humanize", "premium-nextjs:audit"], "platform": "nextjs"
+    "id": "nextjs-full", "pluginName": "premium-web", "skillName": "nextjs", "verb": "full",
+    "invocation": "/premium-web:nextjs", "areas": [], "detects": [],
+    "produces": [], "invokes": ["premium-web:nextjs", "premium-core:growth", "premium-core:humanize"], "platform": "nextjs"
   },
   {
-    "id": "astro-research", "pluginName": "premium-astro", "skillName": "research", "verb": "research",
-    "invocation": "/premium-astro:research", "areas": [], "detects": [],
+    "id": "astro-research", "pluginName": "premium-web", "skillName": "astro", "verb": "research",
+    "invocation": "/premium-web:astro", "areas": [], "detects": [],
     "produces": ["research"], "invokes": ["premium-core:research"], "platform": "astro"
   },
   {
-    "id": "astro-init", "pluginName": "premium-astro", "skillName": "init", "verb": "init",
-    "invocation": "/premium-astro:init", "areas": ["infra", "design-tokens", "monetization", "observability"], "detects": ["missing"],
+    "id": "astro-init", "pluginName": "premium-web", "skillName": "astro", "verb": "init",
+    "invocation": "/premium-web:astro", "areas": ["infra", "design-tokens", "monetization", "observability"], "detects": ["missing"],
     "produces": ["code_fact", "decision"], "invokes": [], "platform": "astro"
   },
   {
-    "id": "astro-configure", "pluginName": "premium-astro", "skillName": "configure", "verb": "configure",
-    "invocation": "/premium-astro:configure", "areas": ["infra", "security", "observability"], "detects": ["needs-work"],
+    "id": "astro-configure", "pluginName": "premium-web", "skillName": "astro", "verb": "configure",
+    "invocation": "/premium-web:astro", "areas": ["infra", "security", "observability"], "detects": ["needs-work"],
     "produces": ["code_fact"], "invokes": [], "platform": "astro"
   },
   {
-    "id": "astro-refactor", "pluginName": "premium-astro", "skillName": "refactor", "verb": "refactor",
-    "invocation": "/premium-astro:refactor", "areas": ["architecture", "design-tokens", "islands-hydration", "copy"], "detects": ["needs-work"],
+    "id": "astro-refactor", "pluginName": "premium-web", "skillName": "astro", "verb": "refactor",
+    "invocation": "/premium-web:astro", "areas": ["architecture", "design-tokens", "islands-hydration", "copy"], "detects": ["needs-work"],
     "produces": ["tech_debt", "code_fact", "decision"], "invokes": ["premium-core:humanize"], "platform": "astro"
   },
   {
-    "id": "astro-create", "pluginName": "premium-astro", "skillName": "create", "verb": "create",
-    "invocation": "/premium-astro:create", "areas": ["design-tokens", "animations", "typography", "icons", "monetization"], "detects": ["missing"],
+    "id": "astro-create", "pluginName": "premium-web", "skillName": "astro", "verb": "create",
+    "invocation": "/premium-web:astro", "areas": ["design-tokens", "animations", "typography", "icons", "monetization"], "detects": ["missing"],
     "produces": ["code_fact", "decision"], "invokes": [], "platform": "astro"
   },
   {
-    "id": "astro-audit", "pluginName": "premium-astro", "skillName": "audit", "verb": "audit",
-    "invocation": "/premium-astro:audit", "areas": ["architecture", "design-tokens", "islands-hydration", "content-collections", "copy", "monetization", "security", "observability", "seo"], "detects": ["missing", "needs-work", "good"],
+    "id": "astro-audit", "pluginName": "premium-web", "skillName": "astro", "verb": "audit",
+    "invocation": "/premium-web:astro", "areas": ["architecture", "design-tokens", "islands-hydration", "content-collections", "copy", "monetization", "security", "observability", "seo"], "detects": ["missing", "needs-work", "good"],
     "produces": ["detection", "tech_debt"], "invokes": ["premium-core:audit"], "platform": "astro"
   },
   {
-    "id": "astro-full", "pluginName": "premium-astro", "skillName": "full", "verb": "full",
-    "invocation": "/premium-astro:full", "areas": [], "detects": [],
-    "produces": [], "invokes": ["premium-astro:research", "premium-astro:init", "premium-astro:configure", "premium-astro:refactor", "premium-astro:create", "premium-core:growth", "premium-core:humanize", "premium-astro:audit"], "platform": "astro"
+    "id": "astro-full", "pluginName": "premium-web", "skillName": "astro", "verb": "full",
+    "invocation": "/premium-web:astro", "areas": [], "detects": [],
+    "produces": [], "invokes": ["premium-web:astro", "premium-core:growth", "premium-core:humanize"], "platform": "astro"
   },
   {
     "id": "marketing-product-context", "pluginName": "marketing-skills", "skillName": "product-marketing-context", "verb": "context",