kongbrain 0.3.11 → 0.3.12

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: kongbrain
 description: Graph-backed persistent memory engine for OpenClaw. Replaces the default context window with SurrealDB + vector embeddings that learn across sessions.
-version: 0.3.11
+version: 0.3.12
 homepage: https://github.com/42U/kongbrain
 metadata:
   openclaw:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "Graph-backed persistent memory engine for OpenClaw. Replaces the default context window with SurrealDB + vector embeddings that learn across sessions.",
   "type": "module",
   "license": "MIT",

package/src/context-engine.ts

@@ -49,7 +49,6 @@ import { extractSkill } from "./skills.js";
 import { generateReflection } from "./reflection.js";
 import { graduateCausalToSkills } from "./skills.js";
 import { swallow } from "./errors.js";
-import { upsertAndLinkConcepts } from "./concept-extract.js";
 
 export class KongBrainContextEngine implements ContextEngine {
   readonly info: ContextEngineInfo = {
@@ -265,11 +264,7 @@ export class KongBrainContextEngine implements ContextEngine {
               .catch(e => swallow.warn("ingest:responds_to", e));
           }
 
-          // Extract and link concepts for both user and assistant turns
-          if (worthEmbedding) {
-            extractAndLinkConcepts(turnId, text, this.state, session)
-              .catch(e => swallow.warn("ingest:concepts", e));
-          }
+          // Concept extraction (mentions edges) handled by daemon via LLM
         }
 
         if (role === "user") {
@@ -400,7 +395,7 @@ export class KongBrainContextEngine implements ContextEngine {
         const turnData = recentTurns.map(t => ({
           role: t.role as "user" | "assistant",
           text: t.text,
-          turnId: (t as any).id,
+          turnId: String((t as any).id ?? ""),
         }));
 
         // Gather retrieved memory IDs for dedup
@@ -441,7 +436,7 @@ export class KongBrainContextEngine implements ContextEngine {
               const turnData = recentTurns.map(t => ({
                 role: t.role as "user" | "assistant",
                 text: t.text,
-                turnId: (t as any).id,
+                turnId: String((t as any).id ?? ""),
               }));
               session.daemon!.sendTurnBatch(turnData, [...session.pendingThinking], []);
             })
@@ -537,16 +532,3 @@ function hasSemantic(text: string): boolean {
 }
 
 // --- Concept extraction (delegates to shared helper) ---
-
-async function extractAndLinkConcepts(
-  turnId: string,
-  text: string,
-  state: GlobalPluginState,
-  session?: SessionState,
-): Promise<void> {
-  await upsertAndLinkConcepts(
-    turnId, "mentions", text,
-    state.store, state.embeddings, "concepts",
-    session ? { taskId: session.taskId, projectId: session.projectId } : undefined,
-  );
-}

package/src/daemon-manager.ts

@@ -121,7 +121,7 @@ export function startMemoryDaemon(
       }
     }
 
-    const counts = await writeExtractionResults(result, sessionId, store, embeddings, priorState, taskId, projectId);
+    const counts = await writeExtractionResults(result, sessionId, store, embeddings, priorState, taskId, projectId, turns);
     extractedTurnCount = turns.length;
   }
 

package/src/daemon-types.ts

@@ -5,6 +5,7 @@
 export interface TurnData {
   role: string;
   text: string;
+  turnId?: string;
   tool_name?: string;
   tool_result?: string;
   file_paths?: string[];

package/src/memory-daemon.ts

@@ -127,12 +127,72 @@ export async function writeExtractionResults(
   priorState: PriorExtractions,
   taskId?: string,
   projectId?: string,
+  turns?: TurnData[],
 ): Promise<ExtractionCounts> {
   const counts: ExtractionCounts = {
     causal: 0, monologue: 0, resolved: 0, concept: 0,
     correction: 0, preference: 0, artifact: 0, decision: 0, skill: 0,
   };
 
+  // ── Phase 1: Upsert concepts first (LLM-extracted) so we have IDs ────
+  // These IDs are used to create mentions/about_concept/artifact_mentions
+  // edges in Phase 2, replacing the old regex-based extraction.
+
+  const extractedConceptIds: string[] = [];
+
+  if (Array.isArray(result.concepts) && result.concepts.length > 0) {
+    for (const c of result.concepts.slice(0, 11)) {
+      if (!c.name || !c.content) continue;
+      if (priorState.conceptNames.includes(c.name)) continue;
+      counts.concept++;
+      priorState.conceptNames.push(c.name);
+      try {
+        let emb: number[] | null = null;
+        if (embeddings.isAvailable()) {
+          try { emb = await embeddings.embed(c.content); } catch (e) { swallow("daemon:embedConcept", e); }
+        }
+        const conceptId = await store.upsertConcept(c.content, emb, `daemon:${sessionId}`);
+        if (conceptId) {
+          extractedConceptIds.push(conceptId);
+          await linkConceptHierarchy(conceptId, c.name, store, embeddings, "daemon:concept");
+          if (taskId) {
+            await store.relate(conceptId, "derived_from", taskId)
+              .catch(e => swallow("daemon:concept:derived_from", e));
+          }
+          if (projectId) {
+            await store.relate(conceptId, "relevant_to", projectId)
+              .catch(e => swallow("daemon:concept:relevant_to", e));
+          }
+        }
+      } catch (e) {
+        swallow.warn("daemon:upsertConcept", e);
+      }
+    }
+  }
+
+  // ── Phase 2: Create mentions edges (turn → concept) using LLM concepts ─
+  // Links batch turns to extracted concepts, replacing regex-based extraction.
+
+  if (extractedConceptIds.length > 0 && turns && turns.length > 0) {
+    const turnIds = turns.map(t => t.turnId).filter((id): id is string => !!id);
+    for (const turnId of turnIds) {
+      for (const conceptId of extractedConceptIds) {
+        store.relate(turnId, "mentions", conceptId)
+          .catch(e => swallow("daemon:mentions", e));
+      }
+    }
+  }
+
+  // ── Phase 3: All other extractions in parallel ───────────────────────
+
+  /** Link a source node to all extracted concepts via the given edge. */
+  const linkToConcepts = async (sourceId: string, edgeName: string) => {
+    for (const conceptId of extractedConceptIds) {
+      await store.relate(sourceId, edgeName, conceptId)
+        .catch(e => swallow(`daemon:${edgeName}`, e));
+    }
+  };
+
   const writeOps: Promise<void>[] = [];
 
   // 1. Causal chains
@@ -187,37 +247,7 @@ export async function writeExtractionResults(
     })());
   }
 
-  // 4. Concepts
-  if (Array.isArray(result.concepts) && result.concepts.length > 0) {
-    for (const c of result.concepts.slice(0, 11)) {
-      if (!c.name || !c.content) continue;
-      if (priorState.conceptNames.includes(c.name)) continue;
-      counts.concept++;
-      priorState.conceptNames.push(c.name);
-      writeOps.push((async () => {
-        let emb: number[] | null = null;
-        if (embeddings.isAvailable()) {
-          try { emb = await embeddings.embed(c.content); } catch (e) { swallow("daemon:embedConcept", e); }
-        }
-        const conceptId = await store.upsertConcept(c.content, emb, `daemon:${sessionId}`);
-        if (conceptId) {
-          await linkConceptHierarchy(conceptId, c.name, store, embeddings, "daemon:concept");
-          // derived_from: concept → task
-          if (taskId) {
-            await store.relate(conceptId, "derived_from", taskId)
-              .catch(e => swallow("daemon:concept:derived_from", e));
-          }
-          // relevant_to: concept → project
-          if (projectId) {
-            await store.relate(conceptId, "relevant_to", projectId)
-              .catch(e => swallow("daemon:concept:relevant_to", e));
-          }
-        }
-      })());
-    }
-  }
-
-  // 5. Corrections — high-importance memories
+  // 4. Corrections — high-importance memories, linked to LLM-extracted concepts
   if (Array.isArray(result.corrections) && result.corrections.length > 0) {
     for (const c of result.corrections.slice(0, 5)) {
       if (!c.original || !c.correction) continue;
@@ -230,13 +260,13 @@ export async function writeExtractionResults(
         }
         const memId = await store.createMemory(text, emb, 9, "correction", sessionId);
         if (memId) {
-          await upsertAndLinkConcepts(memId, "about_concept", text, store, embeddings, "daemon:correction", { taskId, projectId });
+          await linkToConcepts(memId, "about_concept");
         }
       })());
     }
   }
 
-  // 6. User preferences
+  // 5. User preferences
   if (Array.isArray(result.preferences) && result.preferences.length > 0) {
     for (const p of result.preferences.slice(0, 5)) {
       if (!p.preference) continue;
@@ -249,13 +279,13 @@ export async function writeExtractionResults(
         }
         const memId = await store.createMemory(text, emb, 7, "preference", sessionId);
         if (memId) {
-          await upsertAndLinkConcepts(memId, "about_concept", text, store, embeddings, "daemon:preference", { taskId, projectId });
+          await linkToConcepts(memId, "about_concept");
         }
       })());
     }
   }
 
-  // 7. Artifacts
+  // 6. Artifacts
   if (Array.isArray(result.artifacts) && result.artifacts.length > 0) {
     for (const a of result.artifacts.slice(0, 10)) {
       if (!a.path) continue;
@@ -270,7 +300,7 @@ export async function writeExtractionResults(
         }
         const artId = await store.createArtifact(a.path, a.action ?? "modified", desc, emb);
         if (artId) {
-          await upsertAndLinkConcepts(artId, "artifact_mentions", `${a.path} ${desc}`, store, embeddings, "daemon:artifact", { taskId, projectId });
+          await linkToConcepts(artId, "artifact_mentions");
           // used_in: artifact → project
           if (projectId) {
             await store.relate(artId, "used_in", projectId)
@@ -281,7 +311,7 @@ export async function writeExtractionResults(
     }
   }
 
-  // 8. Decisions
+  // 7. Decisions
   if (Array.isArray(result.decisions) && result.decisions.length > 0) {
     for (const d of result.decisions.slice(0, 6)) {
       if (!d.decision) continue;
@@ -294,13 +324,13 @@ export async function writeExtractionResults(
         }
         const memId = await store.createMemory(text, emb, 7, "decision", sessionId);
         if (memId) {
-          await upsertAndLinkConcepts(memId, "about_concept", text, store, embeddings, "daemon:decision", { taskId, projectId });
+          await linkToConcepts(memId, "about_concept");
         }
       })());
     }
   }
 
-  // 9. Skills
+  // 8. Skills — get ID back to create skill_from_task + skill_uses_concept edges
   if (Array.isArray(result.skills) && result.skills.length > 0) {
     for (const s of result.skills.slice(0, 3)) {
       if (!s.name || !Array.isArray(s.steps) || s.steps.length === 0) continue;
@@ -313,21 +343,35 @@ export async function writeExtractionResults(
         if (embeddings.isAvailable()) {
           try { emb = await embeddings.embed(content); } catch (e) { swallow("daemon:embedSkill", e); }
         }
-        await store.queryExec(
-          `CREATE skill CONTENT $record`,
-          {
-            record: {
-              name: String(s.name).slice(0, 100),
-              description: content,
-              content,
-              steps: s.steps.map((st: string) => String(st).slice(0, 200)),
-              trigger_context: String(s.trigger_context ?? "").slice(0, 200),
-              tags: ["auto-extracted"],
-              session_id: sessionId,
-              ...(emb ? { embedding: emb } : {}),
+        try {
+          const rows = await store.queryFirst<{ id: string }>(
+            `CREATE skill CONTENT $record RETURN id`,
+            {
+              record: {
+                name: String(s.name).slice(0, 100),
+                description: content,
+                content,
+                steps: s.steps.map((st: string) => String(st).slice(0, 200)),
+                trigger_context: String(s.trigger_context ?? "").slice(0, 200),
+                tags: ["auto-extracted"],
+                session_id: sessionId,
+                ...(emb ? { embedding: emb } : {}),
+              },
             },
-          },
-        ).catch(e => swallow.warn("daemon:createSkill", e));
+          );
+          const skillId = rows[0]?.id ? String(rows[0].id) : null;
+          if (skillId) {
+            // skill_from_task: skill → task
+            if (taskId) {
+              await store.relate(skillId, "skill_from_task", taskId)
+                .catch(e => swallow.warn("daemon:skill:skill_from_task", e));
+            }
+            // skill_uses_concept: skill → concept
+            await upsertAndLinkConcepts(skillId, "skill_uses_concept", content, store, embeddings, "daemon:skill:concepts");
+          }
+        } catch (e) {
+          swallow.warn("daemon:createSkill", e);
+        }
       })());
     }
   }

package/src/schema.surql

@@ -47,6 +47,8 @@ DEFINE INDEX IF NOT EXISTS artifact_vec_idx ON artifact FIELDS embedding HNSW DI
 -- PILLAR 5: Concept (semantic knowledge nodes)
 -- ============================================================
 DEFINE TABLE IF NOT EXISTS concept SCHEMALESS;
+-- Recovery: restore content from name if the rename migration ran before revert
+UPDATE concept SET content = name WHERE content = NONE AND name != NONE;
 DEFINE FIELD IF NOT EXISTS content ON concept TYPE string;
 DEFINE FIELD IF NOT EXISTS embedding ON concept TYPE option<array<float>>;
 DEFINE FIELD IF NOT EXISTS stability ON concept TYPE float DEFAULT 1.0;

package/src/surreal.ts

@@ -684,6 +684,8 @@ export class SurrealStore {
     embedding: number[] | null,
     source?: string,
   ): Promise<string> {
+    if (!content?.trim()) return "";
+    content = content.trim();
     const rows = await this.queryFirst<{ id: string }>(
       `SELECT id FROM concept WHERE string::lowercase(content) = string::lowercase($content) LIMIT 1`,
       { content },