@feelingmindful/thinking-graph 1.15.1 → 1.20.0

package/dist/tools/recall.js

@@ -1,5 +1,13 @@
 import { z } from 'zod';
 import { NODE_TYPES, EDGE_TYPES } from '../engine/types.js';
+import { classifyIntent } from '../engine/intent.js';
+import { config } from '../config.js';
+// Hybrid (semantic + lexical + recency) recall is on by default; set
+// THINKING_GRAPH_HYBRID_RECALL=false to force the legacy substring path.
+const HYBRID_RECALL_ENABLED = process.env.THINKING_GRAPH_HYBRID_RECALL !== 'false';
+// Graph expansion (multi-hop recall) is on by default; set
+// THINKING_GRAPH_GRAPH_EXPAND=false to disable the 1-hop typed-edge walk.
+const GRAPH_EXPAND_ENABLED = process.env.THINKING_GRAPH_GRAPH_EXPAND !== 'false';
 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'),
@@ -32,23 +40,63 @@ export async function recallHandler(graph, input, vault, projectSlug) {
                         nodes: enriched.filter(Boolean),
                         totalCount: nodes.length,
                         hasMore: nodes.length > (input.limit ?? 20),
+                        intent: classifyIntent(input.query ?? ''),
                     }),
                 }],
         };
     }
-    // Standard query — search SQLite graph
-    const result = await graph.findNodes({
-        query: input.query,
-        type: input.type,
-        sessionId: input.sessionId,
-        projectId: input.projectId,
-        crossProject: input.crossProject,
-        since: input.since,
-        metadata: input.metadata,
-        limit: input.limit,
-        offset: input.offset,
-    });
-    const enriched = await Promise.all(result.items.map(n => graph.getNodeWithEdges(n.id)));
+    // Standard query. Use ranked hybrid recall (semantic + lexical + recency)
+    // when there's a text query and no metadata filter (hybrid does not filter on
+    // metadata — fall back to the substring path to preserve that semantics).
+    const useHybrid = HYBRID_RECALL_ENABLED && !!input.query && !input.metadata;
+    const result = useHybrid
+        ? await graph.recallHybrid({
+            query: input.query,
+            type: input.type,
+            sessionId: input.sessionId,
+            projectId: input.projectId,
+            crossProject: input.crossProject,
+            since: input.since,
+            limit: input.limit,
+            offset: input.offset,
+        })
+        : await graph.findNodes({
+            query: input.query,
+            type: input.type,
+            sessionId: input.sessionId,
+            projectId: input.projectId,
+            crossProject: input.crossProject,
+            since: input.since,
+            metadata: input.metadata,
+            limit: input.limit,
+            offset: input.offset,
+        });
+    // Enrich with edges; carry the fused score through when present (hybrid path).
+    const enriched = await Promise.all(result.items.map(async (n) => {
+        const withEdges = await graph.getNodeWithEdges(n.id);
+        if (!withEdges)
+            return null;
+        const score = n.score;
+        return score === undefined ? withEdges : { ...withEdges, score };
+    }));
+    const enrichedNodes = enriched.filter((n) => n !== null);
+    // Graph expansion (gated). For relationship/causation queries, pull in 1-hop
+    // typed-edge neighbours of the top content hits as structural context. Plain
+    // single-entity lookups skip this so they stay clean and cheap.
+    const intent = classifyIntent(input.query ?? '');
+    const related = [];
+    if (useHybrid && GRAPH_EXPAND_ENABLED && intent.multiHop && enrichedNodes.length > 0) {
+        const present = new Set(enrichedNodes.map(n => n.id));
+        const seedIds = enrichedNodes.slice(0, config.graphSeedCount).map(n => n.id);
+        const neighbors = await graph.expandNeighbors(seedIds, config.graphExpandLimit);
+        for (const nb of neighbors) {
+            if (present.has(nb.id))
+                continue;
+            const withEdges = await graph.getNodeWithEdges(nb.id);
+            if (withEdges)
+                related.push({ ...withEdges, graphExpanded: true });
+        }
+    }
     // Also search Obsidian vault if query text is provided
     let vaultResults = [];
     if (vault && projectSlug && input.query) {
@@ -64,9 +112,14 @@ export async function recallHandler(graph, input, vault, projectSlug) {
         content: [{
                 type: 'text',
                 text: JSON.stringify({
-                    nodes: enriched.filter(Boolean),
+                    nodes: enrichedNodes,
                     totalCount: result.totalCount,
                     hasMore: result.hasMore,
+                    intent,
+                    ...(related.length > 0 && {
+                        related,
+                        relatedCount: related.length,
+                    }),
                     ...(vaultResults.length > 0 && {
                         vault: vaultResults,
                         vaultCount: vaultResults.length,

package/dist/tools/research.js

@@ -65,6 +65,18 @@ function searchFlags(input, recencyDefault) {
     }
     return flags.length ? ` ${flags.join(' ')}` : '';
 }
+// `parallel-cli research run` has no recency/domain flags (unlike `search`), so
+// fold those constraints into the prompt text to avoid silently dropping them.
+function withResearchConstraints(query, input) {
+    const parts = [];
+    const afterDate = afterDateFor(input.recencyFilter);
+    if (afterDate)
+        parts.push(`Only use sources published on or after ${afterDate}.`);
+    if (input.domainFilter?.length) {
+        parts.push(`Restrict sources to these domains: ${input.domainFilter.join(', ')}.`);
+    }
+    return parts.length ? `${query} ${parts.join(' ')}` : query;
+}
 function buildGroundedSteps(input) {
     const steps = [];
     const query = input.query;
@@ -103,8 +115,16 @@ function buildActionPlan(input) {
     if (shouldPrependGrounded) {
         steps.push(...buildGroundedSteps(input));
     }
-    // grounded_qa is NotebookLM-only — no web fallback steps.
+    // grounded_qa prefers NotebookLM, but must still work when NotebookLM isn't
+    // installed or has no matching notebook — append a web-grounded fallback.
     if (input.intent === 'grounded_qa') {
+        steps.push({
+            tool: 'Bash',
+            description: 'Fallback (use only if NotebookLM is unavailable or returned no matching notebook): cited answer via parallel-cli research run',
+            args: {
+                command: `parallel-cli research run --text ${shq(withResearchConstraints(query, input))} --processor pro -o .premium/research/research-grounded`,
+            },
+        });
         return steps;
     }
     // Choose the parallel-cli command based on intent.
@@ -124,7 +144,7 @@ function buildActionPlan(input) {
                 tool: 'Bash',
                 description: 'Step-by-step comparison with web grounding via parallel-cli research run',
                 args: {
-                    command: `parallel-cli research run --text ${shq(query)} --text-description ${shq('step-by-step reasoning')} --processor pro -o .premium/research/research-compare`,
+                    command: `parallel-cli research run --text ${shq(withResearchConstraints(query, input))} --text-description ${shq('step-by-step reasoning')} --processor pro -o .premium/research/research-compare`,
                 },
             });
             break;
@@ -133,7 +153,7 @@ function buildActionPlan(input) {
                 tool: 'Bash',
                 description: 'Deep multi-source research (30s+) via parallel-cli research run',
                 args: {
-                    command: `parallel-cli research run --text ${shq(query)} --processor pro -o .premium/research/research-explore`,
+                    command: `parallel-cli research run --text ${shq(withResearchConstraints(query, input))} --processor pro -o .premium/research/research-explore`,
                 },
             });
             break;

package/dist/tools/think.d.ts

@@ -28,8 +28,8 @@ export declare const thinkSchema: z.ZodObject<{
     branchId: z.ZodOptional<z.ZodString>;
     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";
+    thought: string;
     thoughtNumber: number;
     totalThoughts: number;
     nextThoughtNeeded: boolean;

package/dist/vault/bridge.d.ts

@@ -46,10 +46,11 @@ export declare class VaultBridge {
      */
     write(opts: VaultWriteOpts): string;
     /**
-     * Drop a sentinel at the vault root so the knowledge-graph indexer knows
-     * there are pending writes to flush on the next search. Best-effort: a
-     * failure here must not break the write path, since the consequence is
-     * just a stale `kg_search()` until the next manual `kg_index()`.
+     * Drop a sentinel at the vault root so the knowledge-graph indexer flushes
+     * these pending writes on the next `kg_search()` — it auto-indexes
+     * (incrementally) when the sentinel is present, so search is never stale.
+     * Best-effort: a failure here must not break the write path; it only delays
+     * freshness until a later write re-drops the sentinel or `kg_index()` runs.
      */
     private markPendingIndex;
     /** Read a single note by relative path. */

package/dist/vault/bridge.js

@@ -130,10 +130,11 @@ export class VaultBridge {
         return relative(this.vaultRoot, absPath);
     }
     /**
-     * Drop a sentinel at the vault root so the knowledge-graph indexer knows
-     * there are pending writes to flush on the next search. Best-effort: a
-     * failure here must not break the write path, since the consequence is
-     * just a stale `kg_search()` until the next manual `kg_index()`.
+     * Drop a sentinel at the vault root so the knowledge-graph indexer flushes
+     * these pending writes on the next `kg_search()` — it auto-indexes
+     * (incrementally) when the sentinel is present, so search is never stale.
+     * Best-effort: a failure here must not break the write path; it only delays
+     * freshness until a later write re-drops the sentinel or `kg_index()` runs.
      */
     markPendingIndex() {
         try {
@@ -141,7 +142,8 @@ export class VaultBridge {
             writeFileSync(sentinel, new Date().toISOString(), 'utf-8');
         }
         catch {
-            // Non-fatal — manual `kg_index()` still works as a backstop.
+            // Non-fatal — a later write re-drops the sentinel; `kg_index()` is a
+            // manual backstop.
         }
     }
     // ─── Read ───────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feelingmindful/thinking-graph",
-  "version": "1.15.1",
+  "version": "1.20.0",
   "description": "Persistent graph-based MCP thinking server for the feeling-mindful plugin marketplace",
   "type": "module",
   "main": "dist/index.js",