kongbrain 0.4.0 → 0.4.1

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.4.0
+version: 0.4.1
 homepage: https://github.com/42U/kongbrain
 metadata:
   openclaw:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "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/acan.ts

@@ -273,15 +273,18 @@ function trainInBackground(
     workerData: { samples, cfg, warmStart: warmStart ?? null, EMBED_DIM, ATTN_DIM, FEATURE_COUNT },
   });
 
+  worker.unref();
+
   worker.on("message", (msg: any) => {
     try {
       saveWeights(msg.weights, weightsPath);
       _weights = msg.weights;
       _active = true;
     } catch { /* non-fatal */ }
+    worker.terminate();
   });
 
-  worker.on("error", () => { /* training failure is non-fatal */ });
+  worker.on("error", () => { worker.terminate(); });
 }
 
 // ── Startup: auto-train and activate ──

package/src/cognitive-check.ts

@@ -186,14 +186,14 @@ Return ONLY valid JSON.`,
         assertRecordId(g.id);
         // Direct interpolation safe: assertRecordId validates format above
         await store.queryExec(
-          `UPDATE ${g.id} SET importance = math::max([3, importance - 2])`,
+          `UPDATE ${g.id} SET importance = math::max([3, (importance ?? 5) - 2])`,
         ).catch(e => swallow.warn("cognitive-check:correctionDecay", e));
       } else {
         // Correction was relevant but agent ignored it — reinforce (cap 9)
         assertRecordId(g.id);
         // Direct interpolation safe: assertRecordId validates format above
         await store.queryExec(
-          `UPDATE ${g.id} SET importance = math::min([9, importance + 1])`,
+          `UPDATE ${g.id} SET importance = math::min([9, (importance ?? 5) + 1])`,
         ).catch(e => swallow.warn("cognitive-check:correctionReinforce", e));
       }
     }

package/src/concept-extract.ts

@@ -57,7 +57,7 @@ export async function upsertAndLinkConcepts(
       if (embeddings.isAvailable()) {
         try { embedding = await embeddings.embed(name); } catch { /* ok */ }
       }
-      const conceptId = await store.upsertConcept(name, embedding);
+      const conceptId = await store.upsertConcept(name, embedding, logTag);
       if (conceptId) {
         await store.relate(sourceId, edgeName, conceptId)
           .catch(e => swallow(`${logTag}:relate`, e));

package/src/daemon-manager.ts

@@ -117,12 +117,17 @@ export function startMemoryDaemon(
             try { result[field] = JSON.parse(fieldMatch[1]); } catch { /* skip */ }
           }
         }
-        if (Object.keys(result).length === 0) return;
+        const PRIMARY_FIELDS = ["causal", "monologue", "artifacts"];
+        if (!PRIMARY_FIELDS.some(f => f in result)) return;
       }
     }
 
-    const counts = await writeExtractionResults(result, sessionId, store, embeddings, priorState, taskId, projectId, turns);
-    extractedTurnCount = turns.length;
+    try {
+      const counts = await writeExtractionResults(result, sessionId, store, embeddings, priorState, taskId, projectId, turns);
+      extractedTurnCount = turns.length;
+    } catch (e) {
+      swallow.warn("daemon:writeExtractionResults", e);
+    }
   }
 
   // Pending batch (only keep latest — newer batch supersedes older)
@@ -158,6 +163,9 @@ export function startMemoryDaemon(
   return {
     sendTurnBatch(turns, thinking, retrievedMemories, priorExtractions) {
       if (shuttingDown) return;
+      if (pendingBatch) {
+        swallow.warn("daemon:batchOverwrite", new Error(`Overwriting pending batch (${pendingBatch.turns.length} turns) with new batch (${turns.length} turns)`));
+      }
       pendingBatch = { turns, thinking, retrievedMemories, priorExtractions };
       // Fire-and-forget
       processPending().catch(e => swallow.warn("daemon:sendBatch", e));
@@ -176,14 +184,12 @@ export function startMemoryDaemon(
       shuttingDown = true;
       // Wait for current extraction to finish
       if (processing) {
-        await Promise.race([
-          new Promise<void>(resolve => {
-            const check = setInterval(() => {
-              if (!processing) { clearInterval(check); resolve(); }
-            }, 100);
-          }),
-          new Promise<void>(resolve => setTimeout(resolve, timeoutMs)),
-        ]);
+        await new Promise<void>(resolve => {
+          const check = setInterval(() => {
+            if (!processing) { clearInterval(check); clearTimeout(timeout); resolve(); }
+          }, 100);
+          const timeout = setTimeout(() => { clearInterval(check); resolve(); }, timeoutMs);
+        });
       }
       // Shared store/embeddings — don't dispose (owned by global state)
     },

package/src/deferred-cleanup.ts

@@ -51,18 +51,14 @@ async function runDeferredCleanupInner(
   const orphaned = await store.getOrphanedSessions(10).catch(() => []);
   if (orphaned.length === 0) return 0;
 
-  // Immediately claim all orphaned sessions so no concurrent run can pick them up
-  await Promise.all(
-    orphaned.map(s =>
-      store.markSessionEnded(s.id).catch(e => swallow("deferred:claim", e))
-    )
-  );
-
   let processed = 0;
 
   const cleanup = async () => {
     for (const session of orphaned) {
       try {
+        // Claim each session just before processing so unclaimed ones remain
+        // available to the next run if we time out partway through
+        await store.markSessionEnded(session.id).catch(e => swallow("deferred:claim", e));
         await processOrphanedSession(session.id, store, embeddings, complete);
         processed++;
       } catch (e) {

package/src/handoff-file.ts

@@ -6,7 +6,7 @@
  * so the next session's wakeup has context even before deferred
  * extraction runs.
  */
-import { readFileSync, writeFileSync, unlinkSync, existsSync, chmodSync } from "node:fs";
+import { readFileSync, writeFileSync, unlinkSync, existsSync, renameSync } from "node:fs";
 import { join } from "node:path";
 
 const HANDOFF_FILENAME = ".kongbrain-handoff.json";
@@ -42,14 +42,21 @@ export function readAndDeleteHandoffFile(
   workspaceDir: string,
 ): HandoffFileData | null {
   const path = join(workspaceDir, HANDOFF_FILENAME);
+  const processingPath = path + ".processing";
+  // Also clean up stale .processing files from prior crashes
+  if (existsSync(processingPath) && !existsSync(path)) {
+    try { unlinkSync(processingPath); } catch { /* ignore */ }
+  }
   if (!existsSync(path)) return null;
   try {
-    const raw = readFileSync(path, "utf-8");
-    unlinkSync(path);
+    // Atomic rename first so a crash between read and delete can't re-process
+    renameSync(path, processingPath);
+    const raw = readFileSync(processingPath, "utf-8");
+    unlinkSync(processingPath);
     const parsed = JSON.parse(raw);
     // Runtime validation — reject prototype pollution and malformed data
     if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-    if ("__proto__" in parsed || "constructor" in parsed) return null;
+    if (Object.hasOwn(parsed, "__proto__") || Object.hasOwn(parsed, "constructor")) return null;
     const data: HandoffFileData = {
       sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId.slice(0, 200) : "",
       timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp.slice(0, 50) : "",
@@ -61,7 +68,7 @@ export function readAndDeleteHandoffFile(
     return data;
   } catch {
     // Corrupted or deleted between check and read
-    try { unlinkSync(path); } catch { /* ignore */ }
+    try { unlinkSync(processingPath); } catch { /* ignore */ }
     return null;
   }
 }

package/src/hooks/after-tool-call.ts

@@ -54,7 +54,7 @@ export function createAfterToolCallHandler(state: GlobalPluginState) {
             });
             if (assistantTurnId) session.lastAssistantTurnId = assistantTurnId;
           } catch (e) {
-            swallow("hook:afterToolCall:eagerAssistantTurn", e);
+            swallow.warn("hook:afterToolCall:eagerAssistantTurn", e);
           }
         }
         if (session.lastAssistantTurnId) {
@@ -63,12 +63,12 @@ export function createAfterToolCallHandler(state: GlobalPluginState) {
         }
       }
     } catch (e) {
-      swallow("hook:afterToolCall:store", e);
+      swallow.warn("hook:afterToolCall:store", e);
     }
 
     // Auto-track file artifacts from write/edit tools
     if (!isError) {
-      trackArtifact(event.toolName, event.params, session.taskId, session.projectId, state)
+      await trackArtifact(event.toolName, event.params, session.taskId, session.projectId, state)
         .catch(e => swallow.warn("hook:afterToolCall:artifact", e));
     }
 

package/src/index.ts

@@ -147,11 +147,18 @@ async function runSessionCleanup(
     new Promise(resolve => setTimeout(resolve, 150_000)),
   ]);
 
+  // Await the graduation promise once and reuse the result below
+  let gradResult: Awaited<typeof graduationPromise> = null;
+  try {
+    gradResult = await graduationPromise;
+  } catch (e) {
+    swallow.warn("cleanup:graduationAwait", e);
+  }
+
   // If soul graduation just happened, persist a graduation event so the next
   // session can celebrate with the user. We also fire a system event for
   // immediate visibility if the session is still active.
   try {
-    const gradResult = await graduationPromise;
     if (gradResult?.graduated && gradResult.soul) {
       // Check if this is a NEW graduation (not a pre-existing soul)
       const isNewGraduation = gradResult.report.stage === "ready";
@@ -189,7 +196,6 @@ async function runSessionCleanup(
   // Soul evolution — if soul already exists, check if it should be revised
   // based on new experience (runs every 10 sessions after last revision)
   try {
-    const gradResult = await graduationPromise;
     if (gradResult?.graduated && gradResult.report.stage !== "ready") {
       // Pre-existing soul — check for evolution
       await evolveSoul(s, complete);

package/src/orchestrator.ts

@@ -192,7 +192,7 @@ export async function preflight(
 
   // Non-first-turn short inputs → continuation
   if (orch.turnIndex > 1 && input.length < 20 && !input.includes("?")) {
-    const inheritedLimit = Math.max(orch.lastConfig.toolLimit, 25);
+    const inheritedLimit = Math.min(orch.lastConfig.toolLimit, 25);
     const config: AdaptiveConfig = {
       ...orch.lastConfig, toolLimit: inheritedLimit, skipRetrieval: true,
       vectorSearchLimits: { turn: 0, identity: 0, concept: 0, memory: 0, artifact: 0 },

package/src/reflection.ts

@@ -207,6 +207,7 @@ export async function generateReflection(
       { record },
     );
     const reflectionId = String(rows[0]?.id ?? "");
+    store.clearReflectionCache();
 
     if (reflectionId && surrealSessionId) {
       await store.relate(reflectionId, "reflects_on", surrealSessionId).catch(e => swallow.warn("reflection:relate", e));

package/src/soul.ts

@@ -191,7 +191,7 @@ export async function getQualitySignals(store: SurrealStore): Promise<QualitySig
     const totalSuccess = Number(skillRow?.totalSuccess ?? 0);
     const totalFailure = Number(skillRow?.totalFailure ?? 0);
     const skillTotal = totalSuccess + totalFailure;
-    const skillSuccessRate = skillTotal > 0 ? totalSuccess / skillTotal : 0;
+    const skillSuccessRate = skillTotal > 0 && Number.isFinite(skillTotal) ? totalSuccess / skillTotal : 0;
 
     const critCount = Number(critRow?.count ?? 0);
     const reflCount = Number(totalRow?.count ?? 0);

package/src/surreal.ts

@@ -1408,6 +1408,10 @@ export class SurrealStore {
 
   private _reflectionSessions: Set<string> | null = null;
 
+  clearReflectionCache(): void {
+    this._reflectionSessions = null;
+  }
+
   async getReflectionSessionIds(): Promise<Set<string>> {
     if (this._reflectionSessions) return this._reflectionSessions;
     try {

package/src/tools/recall.ts

@@ -63,7 +63,7 @@ export function createRecallToolDef(state: GlobalPluginState, session: SessionSt
 
         const topIds = results
           .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
-          .slice(0, 5)
+          .slice(0, Math.min(maxResults, 8))
           .map((r) => r.id);
 
         let neighbors: VectorSearchResult[] = [];