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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.3.16",
+  "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/context-engine.ts

@@ -48,6 +48,7 @@ import { runDeferredCleanup } from "./deferred-cleanup.js";
 import { extractSkill } from "./skills.js";
 import { generateReflection } from "./reflection.js";
 import { graduateCausalToSkills } from "./skills.js";
+import { attemptGraduation, evolveSoul, checkStageTransition } from "./soul.js";
 import { swallow } from "./errors.js";
 
 export class KongBrainContextEngine implements ContextEngine {
@@ -152,7 +153,7 @@ export class KongBrainContextEngine implements ContextEngine {
 
     const contextWindow = params.tokenBudget ?? 200000;
 
-    const { messages, stats } = await graphTransformContext({
+    const { messages, stats, systemPromptSection } = await graphTransformContext({
       messages: params.messages,
       session,
       store,
@@ -160,9 +161,24 @@ export class KongBrainContextEngine implements ContextEngine {
       contextWindow,
     });
 
+    // Stash retrieval summary for planning gate (claw-code pattern: pre-compute and show)
+    session.lastRetrievalSummary = stats.graphNodes > 0
+      ? `${stats.graphNodes} context items + ${stats.neighborNodes} neighbors injected (${stats.mode} mode)`
+      : "no graph context retrieved this turn";
+
     // Build system prompt additions
     const additions: string[] = [];
 
+    // Static content for API prefix caching (claw-code: prompt.rs static/dynamic split)
+    if (systemPromptSection) additions.push(systemPromptSection);
+
+    // Compaction summary (claw-code: compact.rs structured signals — inject once after compaction)
+    const compactionSummary = (session as any)._compactionSummary as string | undefined;
+    if (compactionSummary) {
+      additions.push("[POST-COMPACTION CONTEXT]\n" + compactionSummary);
+      delete (session as any)._compactionSummary;
+    }
+
     // Wakeup briefing (synthesized at session start, may still be in-flight)
     const wakeupPromise = (session as any)._wakeupPromise as Promise<string | null> | undefined;
     if (wakeupPromise) {
@@ -318,11 +334,70 @@ export class KongBrainContextEngine implements ContextEngine {
     tokenBudget?: number;
     force?: boolean;
   }): Promise<CompactResult> {
-    // Graph retrieval IS the compaction — ownsCompaction: true
+    // Graph retrieval IS the compaction — ownsCompaction: true.
+    // But we extract structured signals so the model doesn't lose context
+    // about pending work and key files after old messages are dropped.
+    // (claw-code pattern: compact.rs extracts pending work, key files, continuation directive)
+    const sessionKey = params.sessionKey ?? params.sessionId;
+    const session = this.state.getSession(sessionKey);
+    if (session) {
+      session.injectedSections.clear();
+    }
+
+    // Extract structured compaction signals from stored turns
+    let summary: string | undefined;
+    try {
+      const { store } = this.state;
+      if (store.isAvailable()) {
+        const turns = await store.getSessionTurnsRich(params.sessionId, 30);
+        if (turns.length > 0) {
+          const fullText = turns.map(t => t.text).join("\n");
+
+          // Pending work detection (claw-code: compact.rs:235-254)
+          const pendingRe = /\b(todo|next|pending|follow up|remaining|unfinished|still need)\b[^.\n]{0,100}/gi;
+          const pendingMatches = [...fullText.matchAll(pendingRe)]
+            .map(m => m[0].trim().slice(0, 160))
+            .slice(0, 5);
+
+          // Key file extraction (claw-code: compact.rs:256-269)
+          const filePaths = [...new Set(
+            (fullText.match(/[\w\-/.]+\.\w{1,5}/g) ?? [])
+              .filter(p => /\.(ts|js|py|rs|go|md|json|yaml|toml|tsx|jsx)$/.test(p))
+          )].slice(0, 10);
+
+          // Tool names used (claw-code: compact.rs:127-137)
+          const toolNames = [...new Set(
+            turns.filter(t => t.tool_name).map(t => t.tool_name!)
+          )];
+
+          // Current work inference (claw-code: compact.rs:272-279)
+          const lastText = turns.filter(t => t.text.length > 10).at(-1)?.text.slice(0, 200) ?? "";
+
+          const parts: string[] = [];
+          if (pendingMatches.length > 0) parts.push(`PENDING: ${pendingMatches.join("; ")}`);
+          if (filePaths.length > 0) parts.push(`FILES: ${filePaths.join(", ")}`);
+          if (toolNames.length > 0) parts.push(`TOOLS USED: ${toolNames.join(", ")}`);
+          if (lastText) parts.push(`LAST: ${lastText}`);
+          parts.push("Resume directly — do not recap what was happening.");
+
+          if (parts.length > 1) {
+            summary = parts.join("\n");
+            // Stash for next assemble() to inject
+            if (session) {
+              (session as any)._compactionSummary = summary;
+            }
+          }
+        }
+      }
+    } catch { /* non-critical */ }
+
     return {
       ok: true,
-      compacted: false,
-      reason: "Graph retrieval handles context selection; no LLM-based compaction needed.",
+      compacted: !!summary,
+      reason: summary
+        ? "Extracted structured signals for continuation."
+        : "Graph retrieval handles context selection; no LLM-based compaction needed.",
+      result: summary ? { summary, tokensBefore: 0 } : undefined,
     };
   }
 
@@ -494,6 +569,55 @@ export class KongBrainContextEngine implements ContextEngine {
         })().catch(e => swallow.warn("midCleanup:handoff", e)),
       );
 
+      // Soul graduation + stage transition — run mid-session so marathon
+      // sessions don't miss milestones that would normally fire at session_end
+      cleanupOps.push(
+        (async () => {
+          const gradResult = await attemptGraduation(store, this.state.complete);
+          if (gradResult?.graduated && gradResult.soul) {
+            if (gradResult.report.stage === "ready") {
+              // New graduation — persist event for celebration
+              await store.queryExec(
+                `CREATE graduation_event CONTENT $data`,
+                {
+                  data: {
+                    session_id: session.sessionId,
+                    acknowledged: false,
+                    quality_score: gradResult.report.qualityScore,
+                    volume_score: gradResult.report.volumeScore,
+                    stage: gradResult.report.stage,
+                    created_at: new Date().toISOString(),
+                  },
+                },
+              );
+              if (this.state.enqueueSystemEvent) {
+                this.state.enqueueSystemEvent(
+                  "[GRADUATION] KongBrain has achieved soul graduation! " +
+                  "The agent will share this milestone when ready.",
+                  { sessionKey: session.sessionKey },
+                );
+              }
+            } else {
+              // Pre-existing soul — check for evolution
+              await evolveSoul(store, this.state.complete);
+            }
+          }
+        })().catch(e => swallow.warn("midCleanup:soulGraduation", e)),
+      );
+
+      cleanupOps.push(
+        (async () => {
+          const transition = await checkStageTransition(store);
+          if (transition.transitioned && this.state.enqueueSystemEvent) {
+            this.state.enqueueSystemEvent(
+              `[MATURITY] Stage transition: ${transition.previousStage ?? "nascent"} → ${transition.currentStage}. ` +
+              `Volume: ${transition.report.met.length}/7 | Quality: ${transition.report.qualityScore.toFixed(2)}`,
+              { sessionKey: session.sessionKey },
+            );
+          }
+        })().catch(e => swallow.warn("midCleanup:stageTransition", e)),
+      );
+
       // Don't await — let cleanup run in background
       Promise.allSettled(cleanupOps).catch(() => {});
     }

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) {