@feelingmindful/thinking-graph 1.14.1 → 1.15.1

package/dist/engine/graph.js

@@ -257,7 +257,7 @@ export class ThinkingGraph {
             { name: 'relate', used: relateUsed, purpose: 'connect nodes with typed edges' },
             { name: 'recall', used: null, purpose: 'query prior knowledge (not trackable)' },
             { name: 'learn', used: learnUsed, purpose: 'persist insights cross-project' },
-            { name: 'research', used: researchUsed, purpose: 'web research via Perplexity/Firecrawl' },
+            { name: 'research', used: researchUsed, purpose: 'web research via parallel-cli' },
         ];
         lines.push('', '## Tool Utilization');
         for (const t of tools) {

package/dist/index.js

@@ -4,7 +4,7 @@ import { homedir } from 'os';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ThinkingGraph } from './engine/graph.js';
-import { SQLiteAdapter } from './storage/sqlite.js';
+import { JSONLAdapter } from './storage/jsonl.js';
 import { InMemoryAdapter } from './storage/memory.js';
 import { VaultBridge } from './vault/bridge.js';
 import { thinkSchema, thinkHandler } from './tools/think.js';
@@ -26,8 +26,8 @@ function expandHome(p) {
 const memoryOnly = process.env.THINKING_GRAPH_MEMORY_ONLY === 'true';
 const storage = memoryOnly
     ? new InMemoryAdapter()
-    : new SQLiteAdapter({
-        dbPath: expandHome(process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'),
+    : new JSONLAdapter({
+        dir: expandHome(process.env.THINKING_GRAPH_DATA_DIR || '.premium/thinking'),
     });
 // ─── Vault bridge ────────────────────────────────────────
 const vaultPath = expandHome(process.env.THINKING_GRAPH_VAULT_PATH || '~/Documents/Obsidian/Dev');
@@ -56,7 +56,7 @@ server.tool('relate', 'Create a typed, directional relationship between two node
 server.tool('recall', 'Query the thinking graph and Obsidian vault — search by text, filter by type, traverse relationships, or search across projects.', recallSchema.shape, async (input) => recallHandler(graph, input, vault, projectSlug));
 server.tool('learn', 'Store durable knowledge — code facts, tech debt, insights, principles. Writes to both SQLite graph and Obsidian vault.', learnSchema.shape, async (input) => learnHandler(graph, input, vault, projectSlug));
 server.tool('export', 'Export the thinking graph as JSON or a human-readable markdown summary.', exportSchema.shape, async (input) => exportHandler(graph, input));
-server.tool('research', 'Research a topic using Perplexity/Firecrawl, then ingest findings into the graph and Obsidian vault. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input, vault, projectSlug));
+server.tool('research', 'Research a topic using parallel-cli, then ingest findings into the graph and Obsidian vault. Two-phase: call once to get an action plan, then again with findings to store them.', researchSchema.shape, async (input) => researchHandler(graph, input, vault, projectSlug));
 server.tool('recommend-skills', 'Recommend installed marketplace skills by area, verb, platform, or what they produce/detect. Use during reasoning to find skills that can help with the current task.', recommendSkillsSchema.shape, async (input) => recommendSkillsHandler(graph, input));
 server.tool('route-skills', 'Shortlist and rank installed skills for a task using routing heuristics based on platform, verb, areas, detections, and graph context.', routeSkillsSchema.shape, async (input) => routeSkillsHandler(graph, input));
 server.tool('plan-skills', 'Convert a request into an ordered skill execution plan with explicit approval gates before execution. This tool plans but does not execute skills.', planSkillsSchema.shape, async (input) => planSkillsHandler(graph, input));
@@ -70,9 +70,9 @@ async function main() {
     await server.connect(transport);
     if (!process.env.DISABLE_THOUGHT_LOGGING) {
         console.error('thinking-graph MCP server started');
-        console.error(`  Storage: ${memoryOnly ? 'in-memory' : 'SQLite'}`);
+        console.error(`  Storage: ${memoryOnly ? 'in-memory' : 'JSONL'}`);
         if (!memoryOnly) {
-            console.error(`  DB: ${process.env.THINKING_GRAPH_PROJECT_DB || '.premium/thinking.db'}`);
+            console.error(`  Dir: ${process.env.THINKING_GRAPH_DATA_DIR || '.premium/thinking'}`);
         }
         console.error(`  Vault: ${vault.root}`);
         console.error(`  Project: ${projectSlug}`);

package/dist/storage/embedding.d.ts

@@ -0,0 +1 @@
+export declare function embedText(text: string): Promise<Float32Array | null>;

package/dist/storage/embedding.js

@@ -0,0 +1,32 @@
+let pipeline = null;
+let initPromise = null;
+async function loadPipeline() {
+    try {
+        const { pipeline: createPipeline } = await import('@xenova/transformers');
+        const pipe = await createPipeline('feature-extraction', 'Xenova/bge-small-en-v1.5', {
+            quantized: true,
+        });
+        pipeline = async (text) => {
+            const output = await pipe(text, { pooling: 'mean', normalize: true });
+            return new Float32Array(output.data);
+        };
+    }
+    catch {
+        pipeline = null;
+    }
+}
+export async function embedText(text) {
+    if (process.env.THINKING_GRAPH_EMBEDDINGS === 'false')
+        return null;
+    if (!initPromise)
+        initPromise = loadPipeline();
+    await initPromise;
+    if (!pipeline)
+        return null;
+    try {
+        return await pipeline(text);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/storage/jsonl.d.ts

@@ -0,0 +1,23 @@
+import type { Node, Edge, Session, SkillRegistryEntry } from '../engine/types.js';
+import { InMemoryAdapter } from './memory.js';
+export interface JSONLAdapterOpts {
+    dir: string;
+}
+export declare class JSONLAdapter extends InMemoryAdapter {
+    private readonly nodesPath;
+    private readonly edgesPath;
+    private readonly sessionsPath;
+    private readonly skillsPath;
+    private readonly embeddingsPath;
+    private readonly vectorIndex;
+    constructor(opts: JSONLAdapterOpts);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    private maybeRunSqliteMigration;
+    insertNode(node: Node): Promise<void>;
+    searchContent(query: string): Promise<Node[]>;
+    insertEdge(edge: Edge): Promise<boolean>;
+    insertSession(session: Session): Promise<void>;
+    updateSession(id: string, fields: Partial<Session>): Promise<void>;
+    insertSkill(entry: SkillRegistryEntry): Promise<void>;
+}

package/dist/storage/jsonl.js

@@ -0,0 +1,138 @@
+import { readFileSync, appendFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { InMemoryAdapter } from './memory.js';
+import { embedText } from './embedding.js';
+import { VectorIndex } from './vector-index.js';
+import { migrateSqliteToJsonl } from './migrate-sqlite.js';
+export class JSONLAdapter extends InMemoryAdapter {
+    nodesPath;
+    edgesPath;
+    sessionsPath;
+    skillsPath;
+    embeddingsPath;
+    vectorIndex = new VectorIndex();
+    constructor(opts) {
+        super();
+        this.nodesPath = join(opts.dir, 'nodes.jsonl');
+        this.edgesPath = join(opts.dir, 'edges.jsonl');
+        this.sessionsPath = join(opts.dir, 'sessions.jsonl');
+        this.skillsPath = join(opts.dir, 'skills.jsonl');
+        this.embeddingsPath = join(opts.dir, 'embeddings.ndjson');
+    }
+    async initialize() {
+        mkdirSync(join(this.nodesPath, '..'), { recursive: true });
+        await this.maybeRunSqliteMigration();
+        for (const line of readLines(this.nodesPath)) {
+            await super.insertNode(JSON.parse(line));
+        }
+        for (const line of readLines(this.edgesPath)) {
+            await super.insertEdge(JSON.parse(line));
+        }
+        // Sessions: last line wins for each id (handles updateSession appends)
+        const sessionMap = new Map();
+        for (const line of readLines(this.sessionsPath)) {
+            const s = JSON.parse(line);
+            sessionMap.set(s.id, s);
+        }
+        for (const s of sessionMap.values()) {
+            await super.insertSession(s);
+        }
+        // Skills: deduplicated by id
+        const skillMap = new Map();
+        for (const line of readLines(this.skillsPath)) {
+            const sk = JSON.parse(line);
+            skillMap.set(sk.id, sk);
+        }
+        for (const sk of skillMap.values()) {
+            await super.insertSkill(sk);
+        }
+        this.vectorIndex.load(this.embeddingsPath);
+    }
+    async close() { }
+    async maybeRunSqliteMigration() {
+        const dbPath = process.env.THINKING_GRAPH_PROJECT_DB;
+        if (!dbPath)
+            return;
+        if (!existsSync(dbPath))
+            return;
+        // Only migrate if JSONL store is empty (first run after upgrade)
+        if (existsSync(this.nodesPath))
+            return;
+        console.error(`[thinking-graph] Migrating SQLite data from ${dbPath} to JSONL...`);
+        try {
+            const counts = await migrateSqliteToJsonl({
+                dbPath,
+                nodesPath: this.nodesPath,
+                edgesPath: this.edgesPath,
+                sessionsPath: this.sessionsPath,
+                skillsPath: this.skillsPath,
+            });
+            console.error(`[thinking-graph] Migration complete: ${counts.nodes} nodes, ${counts.edges} edges, ${counts.sessions} sessions, ${counts.skills} skills`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[thinking-graph] SQLite migration skipped: ${msg}`);
+        }
+    }
+    // ─── Nodes ─────────────────────────────────────────────
+    async insertNode(node) {
+        await super.insertNode(node);
+        appendLine(this.nodesPath, node);
+        const vec = await embedText(node.content);
+        if (vec)
+            this.vectorIndex.append(this.embeddingsPath, node.id, vec);
+    }
+    async searchContent(query) {
+        const vec = await embedText(query);
+        if (!vec)
+            return super.searchContent(query);
+        const matches = this.vectorIndex.search(vec, 20).filter(m => m.score >= 0.5);
+        if (matches.length === 0)
+            return super.searchContent(query);
+        const nodes = [];
+        for (const { id } of matches) {
+            const node = await super.getNode(id);
+            if (node)
+                nodes.push(node);
+        }
+        return nodes;
+    }
+    // ─── Edges ─────────────────────────────────────────────
+    async insertEdge(edge) {
+        const created = await super.insertEdge(edge);
+        if (created)
+            appendLine(this.edgesPath, edge);
+        return created;
+    }
+    // ─── Sessions ──────────────────────────────────────────
+    async insertSession(session) {
+        await super.insertSession(session);
+        appendLine(this.sessionsPath, session);
+    }
+    async updateSession(id, fields) {
+        await super.updateSession(id, fields);
+        const updated = await super.getSession(id);
+        if (updated)
+            appendLine(this.sessionsPath, updated);
+    }
+    // ─── Skill Registry ───────────────────────────────────
+    async insertSkill(entry) {
+        // Idempotent: skip if already in memory (loaded from file or previously seeded)
+        const existing = await this.querySkills({ id: entry.id });
+        if (existing.length > 0)
+            return;
+        await super.insertSkill(entry);
+        appendLine(this.skillsPath, entry);
+    }
+}
+// ─── Helpers ───────────────────────────────────────────
+function readLines(path) {
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, 'utf-8')
+        .split('\n')
+        .filter(line => line.trim().length > 0);
+}
+function appendLine(path, value) {
+    appendFileSync(path, JSON.stringify(value) + '\n', 'utf-8');
+}

package/dist/storage/migrate-sqlite.d.ts

@@ -0,0 +1,12 @@
+export declare function migrateSqliteToJsonl(opts: {
+    dbPath: string;
+    nodesPath: string;
+    edgesPath: string;
+    sessionsPath: string;
+    skillsPath: string;
+}): Promise<{
+    nodes: number;
+    edges: number;
+    sessions: number;
+    skills: number;
+}>;

package/dist/storage/migrate-sqlite.js

@@ -0,0 +1,75 @@
+import { existsSync, appendFileSync } from 'fs';
+function appendLine(path, value) {
+    appendFileSync(path, JSON.stringify(value) + '\n', 'utf-8');
+}
+export async function migrateSqliteToJsonl(opts) {
+    if (!existsSync(opts.dbPath)) {
+        throw new Error(`SQLite database not found: ${opts.dbPath}`);
+    }
+    let Database;
+    try {
+        const mod = await import('better-sqlite3');
+        Database = mod.default;
+    }
+    catch {
+        throw new Error('better-sqlite3 not available. Install it to run migration:\n' +
+            '  npm install better-sqlite3\n' +
+            'Then retry, or migrate manually by exporting data from the old database.');
+    }
+    const db = new Database(opts.dbPath);
+    try {
+        const nodes = db.prepare('SELECT * FROM nodes').all();
+        for (const r of nodes) {
+            const node = {
+                id: r.id, type: r.type, content: r.content,
+                sessionId: r.session_id, projectId: r.project_id ?? undefined,
+                metadata: JSON.parse(r.metadata || '{}'),
+                createdAt: r.created_at, updatedAt: r.updated_at,
+                thoughtNumber: r.thought_number ?? undefined,
+                totalThoughts: r.total_thoughts ?? undefined,
+                branchId: r.branch_id ?? undefined,
+                isRevision: r.is_revision === 1,
+                revisesThought: r.revises_thought ?? undefined,
+            };
+            appendLine(opts.nodesPath, node);
+        }
+        const edges = db.prepare('SELECT * FROM edges').all();
+        for (const r of edges) {
+            const edge = {
+                id: r.id, sourceId: r.source_id, targetId: r.target_id,
+                type: r.type, weight: r.weight,
+                reasoning: r.reasoning ?? undefined, createdAt: r.created_at,
+            };
+            appendLine(opts.edgesPath, edge);
+        }
+        const sessions = db.prepare('SELECT * FROM sessions').all();
+        for (const r of sessions) {
+            const session = {
+                id: r.id, projectId: r.project_id ?? undefined,
+                projectPath: r.project_path ?? undefined,
+                description: r.description ?? undefined,
+                startedAt: r.started_at, lastActiveAt: r.last_active,
+            };
+            appendLine(opts.sessionsPath, session);
+        }
+        let skills = [];
+        try {
+            skills = db.prepare('SELECT * FROM skill_registry').all();
+        }
+        catch { /* table may not exist in older DBs */ }
+        for (const r of skills) {
+            const skill = {
+                id: r.id, pluginName: r.plugin_name, skillName: r.skill_name,
+                verb: r.verb ?? undefined, invocation: r.invocation,
+                areas: JSON.parse(r.areas), detects: JSON.parse(r.detects),
+                produces: JSON.parse(r.produces), invokes: JSON.parse(r.invokes),
+                platform: r.platform ?? undefined,
+            };
+            appendLine(opts.skillsPath, skill);
+        }
+        return { nodes: nodes.length, edges: edges.length, sessions: sessions.length, skills: skills.length };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/storage/vector-index.d.ts

@@ -0,0 +1,11 @@
+export interface VectorMatch {
+    id: string;
+    score: number;
+}
+export declare class VectorIndex {
+    private readonly vectors;
+    load(path: string): void;
+    append(path: string, id: string, vec: Float32Array): void;
+    search(queryVec: Float32Array, topK: number): VectorMatch[];
+    has(id: string): boolean;
+}

package/dist/storage/vector-index.js

@@ -0,0 +1,35 @@
+import { readFileSync, appendFileSync, existsSync } from 'fs';
+export class VectorIndex {
+    vectors = new Map();
+    load(path) {
+        if (!existsSync(path))
+            return;
+        for (const line of readFileSync(path, 'utf-8').split('\n')) {
+            if (!line.trim())
+                continue;
+            const { id, vec } = JSON.parse(line);
+            this.vectors.set(id, new Float32Array(vec));
+        }
+    }
+    append(path, id, vec) {
+        this.vectors.set(id, vec);
+        appendFileSync(path, JSON.stringify({ id, vec: Array.from(vec) }) + '\n', 'utf-8');
+    }
+    search(queryVec, topK) {
+        const results = [];
+        for (const [id, vec] of this.vectors) {
+            results.push({ id, score: dot(queryVec, vec) });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, topK);
+    }
+    has(id) {
+        return this.vectors.has(id);
+    }
+}
+function dot(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++)
+        sum += a[i] * b[i];
+    return sum;
+}

package/dist/tools/plan-skills.d.ts

@@ -13,7 +13,7 @@ export declare const planSkillsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;
@@ -23,7 +23,7 @@ export declare const planSkillsSchema: z.ZodObject<{
 }, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;

package/dist/tools/recommend-skills.d.ts

@@ -11,14 +11,14 @@ export declare const recommendSkillsSchema: z.ZodObject<{
     verb?: string | undefined;
     detects?: string | undefined;
     produces?: string | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     area?: string | undefined;
     query?: string | undefined;
 }, {
     verb?: string | undefined;
     detects?: string | undefined;
     produces?: string | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     area?: string | undefined;
     query?: string | undefined;
 }>;

package/dist/tools/research.js

@@ -27,12 +27,44 @@ export const researchSchema = z.object({
     findings: z.array(findingSchema).optional().describe('Results to store (phase 2)'),
     // Options
     projectId: z.string().optional(),
-    scrapeUrls: z.array(z.string()).optional().describe('Specific URLs to scrape with Firecrawl'),
+    scrapeUrls: z.array(z.string()).optional().describe('Specific URLs to extract with `parallel-cli extract`'),
     recencyFilter: z.enum(['hour', 'day', 'week', 'month', 'year']).optional().describe('How recent results should be'),
     domainFilter: z.array(z.string()).optional().describe('Restrict to these domains'),
     notebookId: z.string().optional().describe('Specific NotebookLM notebook ID to query. If omitted, action plan will list notebooks first so the caller can pick the best match.'),
     skipGrounded: coerceBool.optional().describe('Skip NotebookLM step even when it would normally auto-prepend'),
 });
+// parallel-cli is a shell CLI (run via Bash), not an MCP. Every research/scrape
+// step shells out to `parallel-cli`. Recency filters map to `--after-date`.
+const RECENCY_TO_DAYS = {
+    hour: 1,
+    day: 1,
+    week: 7,
+    month: 30,
+    year: 365,
+};
+function afterDateFor(recency) {
+    if (!recency)
+        return undefined;
+    const days = RECENCY_TO_DAYS[recency];
+    if (!days)
+        return undefined;
+    const d = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+    return d.toISOString().slice(0, 10); // YYYY-MM-DD
+}
+// Shell-quote a single argument so queries with spaces/quotes stay intact.
+function shq(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function searchFlags(input, recencyDefault) {
+    const flags = [];
+    const afterDate = afterDateFor(input.recencyFilter ?? recencyDefault);
+    if (afterDate)
+        flags.push(`--after-date ${afterDate}`);
+    if (input.domainFilter?.length) {
+        flags.push(`--include-domains ${input.domainFilter.map(shq).join(',')}`);
+    }
+    return flags.length ? ` ${flags.join(' ')}` : '';
+}
 function buildGroundedSteps(input) {
     const steps = [];
     const query = input.query;
@@ -75,90 +107,74 @@ function buildActionPlan(input) {
     if (input.intent === 'grounded_qa') {
         return steps;
     }
-    // Choose Perplexity tool based on intent
+    // Choose the parallel-cli command based on intent.
+    // search → facts/quick; research run → deep multi-source/reasoning.
     switch (input.intent) {
         case 'fact_check':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_ask',
-                description: 'Quick fact check with citations',
+                tool: 'Bash',
+                description: 'Quick fact check with citations via parallel-cli search',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_context_size: 'medium',
-                    ...(input.recencyFilter && { search_recency_filter: input.recencyFilter }),
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli search ${shq(query)}${searchFlags(input)}`,
                 },
             });
             break;
         case 'compare':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_reason',
-                description: 'Step-by-step comparison with web grounding',
+                tool: 'Bash',
+                description: 'Step-by-step comparison with web grounding via parallel-cli research run',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_context_size: 'high',
-                    ...(input.recencyFilter && { search_recency_filter: input.recencyFilter }),
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli research run --text ${shq(query)} --text-description ${shq('step-by-step reasoning')} --processor pro -o .premium/research/research-compare`,
                 },
             });
             break;
         case 'explore':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_research',
-                description: 'Deep multi-source research (30s+)',
+                tool: 'Bash',
+                description: 'Deep multi-source research (30s+) via parallel-cli research run',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    reasoning_effort: 'medium',
+                    command: `parallel-cli research run --text ${shq(query)} --processor pro -o .premium/research/research-explore`,
                 },
             });
             break;
         case 'how_to':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_ask',
-                description: 'Find implementation guidance',
+                tool: 'Bash',
+                description: 'Find implementation guidance via parallel-cli search',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_context_size: 'high',
-                    ...(input.recencyFilter && { search_recency_filter: input.recencyFilter }),
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli search ${shq(query)} --mode advanced${searchFlags(input)}`,
                 },
             });
             break;
         case 'current_state':
             steps.push({
-                tool: 'mcp__perplexity__perplexity_ask',
-                description: 'Get current state with recency filter',
+                tool: 'Bash',
+                description: 'Get current state with recency filter via parallel-cli search',
                 args: {
-                    messages: [{ role: 'user', content: query }],
-                    search_recency_filter: input.recencyFilter ?? 'week',
-                    search_context_size: 'medium',
-                    ...(input.domainFilter && { search_domain_filter: input.domainFilter }),
+                    command: `parallel-cli search ${shq(query)}${searchFlags(input, 'week')}`,
                 },
             });
             break;
     }
-    // If specific URLs provided, add Firecrawl scrape steps
+    // If specific URLs provided, add parallel-cli extract steps
     if (input.scrapeUrls?.length) {
         for (const url of input.scrapeUrls) {
             steps.push({
-                tool: 'mcp__firecrawl__firecrawl_scrape',
-                description: `Scrape ${url}`,
+                tool: 'Bash',
+                description: `Extract clean markdown from ${url} via parallel-cli extract`,
                 args: {
-                    url,
-                    formats: ['markdown'],
-                    onlyMainContent: true,
+                    command: `parallel-cli extract ${shq(url)}`,
                 },
             });
         }
     }
-    // For explore/compare, also suggest a Firecrawl search for additional sources
+    // For explore/compare, also suggest a parallel-cli search for additional sources
     if (input.intent === 'explore' || input.intent === 'compare') {
         steps.push({
-            tool: 'mcp__firecrawl__firecrawl_search',
-            description: 'Search for additional sources',
+            tool: 'Bash',
+            description: 'Search for additional sources via parallel-cli search',
             args: {
-                query,
-                limit: 5,
-                sources: [{ type: 'web' }],
+                command: `parallel-cli search ${shq(query)} --max-results 5`,
             },
         });
     }
@@ -285,6 +301,7 @@ export async function researchHandler(graph, input, vault, projectSlug) {
                     researchId: node.id,
                     query: input.query,
                     intent: input.intent,
+                    prerequisite: 'parallel-cli must be installed and authenticated. Install: `npm i -g parallel-cli` (or `pipx install parallel-cli`). Auth: run `parallel-cli login` (device OAuth) or set PARALLEL_API_KEY. Verify with `parallel-cli auth`.',
                     actionPlan,
                     ingestStep: {
                         tool: 'research',

package/dist/tools/route-skills.d.ts

@@ -11,7 +11,7 @@ export declare const routeSkillsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;
@@ -19,7 +19,7 @@ export declare const routeSkillsSchema: z.ZodObject<{
 }, {
     request: string;
     areas?: string[] | undefined;
-    platform?: "all" | "web" | "ios" | "android" | undefined;
+    platform?: "all" | "ios" | "android" | "web" | undefined;
     currentState?: "unknown" | "new" | "existing" | undefined;
     goalVerb?: string | undefined;
     detectedNeeds?: string[] | undefined;

package/dist/tools/think.js

@@ -65,7 +65,7 @@ function buildSuggestions(type, thoughtNumber, relatedCount, stats, matchedSkill
     if (type === 'research') {
         suggestions.push({
             tool: 'research',
-            when: 'Use the research tool instead — it generates an action plan with Perplexity/Firecrawl calls and handles ingestion',
+            when: 'Use the research tool instead — it generates an action plan with `parallel-cli` (search/research run/extract) calls and handles ingestion',
             example: { query: '<what to research>', intent: 'explore' },
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.14.1",
+  "version": "1.15.1",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@xenova/transformers": "^2.17.2",
     "ajv": "^8.17.1",
-    "better-sqlite3": "^12.8.0",
     "gray-matter": "^4.0.3",
     "uuid": "^10.0.0",
     "zod": "^3.23.0"
@@ -41,6 +41,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.5.0",
     "@types/uuid": "^10.0.0",
+    "better-sqlite3": "^12.8.0",
     "typescript": "^5.5.0",
     "vitest": "^3.0.0"
   }