kongbrain 0.1.4 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.1.4",
+  "version": "0.2.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/causal.ts

@@ -86,7 +86,7 @@ export async function linkCausalEdges(
       // Store chain metadata
       await store.queryExec(`CREATE causal_chain CONTENT $data`, {
         data: {
-          session_id: sessionId,
+          session_id: String(sessionId),
           trigger_memory: triggerId,
           outcome_memory: outcomeId,
           description_memory: descriptionId,

package/src/context-engine.ts

@@ -9,6 +9,7 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import { startMemoryDaemon } from "./daemon-manager.js";
 import type {
   ContextEngine, ContextEngineInfo,
 } from "openclaw/plugin-sdk";
@@ -45,6 +46,10 @@ import { evaluateRetrieval, getStagedItems } from "./retrieval-quality.js";
 import { shouldRunCheck, runCognitiveCheck } from "./cognitive-check.js";
 import { checkACANReadiness } from "./acan.js";
 import { predictQueries, prefetchContext } from "./prefetch.js";
+import { runDeferredCleanup } from "./deferred-cleanup.js";
+import { extractSkill } from "./skills.js";
+import { generateReflection } from "./reflection.js";
+import { graduateCausalToSkills } from "./skills.js";
 import { swallow } from "./errors.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -87,32 +92,41 @@ export class KongBrainContextEngine implements ContextEngine {
     const sessionKey = params.sessionKey ?? params.sessionId;
     const session = this.state.getOrCreateSession(sessionKey, params.sessionId);
 
-    try {
-      const workspace = this.state.workspaceDir || process.cwd();
-      const projectName = workspace.split("/").pop() || "default";
-
-      session.agentId = await store.ensureAgent("kongbrain", "openclaw-default");
-      session.projectId = await store.ensureProject(projectName);
-      await store.linkAgentToProject(session.agentId, session.projectId)
-        .catch(e => swallow.warn("bootstrap:linkAgentToProject", e));
-
-      session.taskId = await store.createTask(`Session in ${projectName}`);
-      await store.linkAgentToTask(session.agentId, session.taskId)
-        .catch(e => swallow.warn("bootstrap:linkAgentToTask", e));
-      await store.linkTaskToProject(session.taskId, session.projectId)
-        .catch(e => swallow.warn("bootstrap:linkTaskToProject", e));
-
-      const surrealSessionId = await store.createSession(session.agentId);
-      await store.markSessionActive(surrealSessionId)
-        .catch(e => swallow.warn("bootstrap:markActive", e));
-      await store.linkSessionToTask(surrealSessionId, session.taskId)
-        .catch(e => swallow.warn("bootstrap:linkSessionToTask", e));
-
-      // Store the DB session ID for cleanup tracking
-      session.surrealSessionId = surrealSessionId;
-      session.lastUserTurnId = "";
-    } catch (e) {
-      swallow.error("bootstrap:5pillar", e);
+    // Only create graph nodes on first bootstrap for this session
+    if (!session.surrealSessionId) {
+      try {
+        const workspace = this.state.workspaceDir || process.cwd();
+        const projectName = workspace.split("/").pop() || "default";
+
+        session.agentId = await store.ensureAgent("kongbrain", "openclaw-default");
+        session.projectId = await store.ensureProject(projectName);
+        await store.linkAgentToProject(session.agentId, session.projectId)
+          .catch(e => swallow.warn("bootstrap:linkAgentToProject", e));
+
+        session.taskId = await store.createTask(`Session in ${projectName}`);
+        await store.linkAgentToTask(session.agentId, session.taskId)
+          .catch(e => swallow.warn("bootstrap:linkAgentToTask", e));
+        await store.linkTaskToProject(session.taskId, session.projectId)
+          .catch(e => swallow.warn("bootstrap:linkTaskToProject", e));
+
+        const surrealSessionId = await store.createSession(session.agentId);
+        await store.markSessionActive(surrealSessionId)
+          .catch(e => swallow.warn("bootstrap:markActive", e));
+        await store.linkSessionToTask(surrealSessionId, session.taskId)
+          .catch(e => swallow.warn("bootstrap:linkSessionToTask", e));
+
+        session.surrealSessionId = surrealSessionId;
+        session.lastUserTurnId = "";
+
+        // Start memory daemon for this session
+        if (!session.daemon) {
+          session.daemon = startMemoryDaemon(
+            store, embeddings, session.sessionId, this.state.complete,
+          );
+        }
+      } catch (e) {
+        swallow.error("bootstrap:5pillar", e);
+      }
     }
 
     // Background maintenance (non-blocking)
@@ -122,6 +136,7 @@ export class KongBrainContextEngine implements ContextEngine {
       store.consolidateMemories((text) => embeddings.embed(text)),
       store.garbageCollectMemories(),
       checkACANReadiness(store),
+      // Deferred cleanup is triggered on first afterTurn() when complete() is available
     ]).catch(e => swallow.warn("bootstrap:maintenance", e));
 
     return { bootstrapped: true };
@@ -154,11 +169,12 @@ export class KongBrainContextEngine implements ContextEngine {
     // Build system prompt additions
     const additions: string[] = [];
 
-    // Wakeup briefing (synthesized at session start)
-    const wakeupBriefing = (session as any)._wakeupBriefing as string | undefined;
-    if (wakeupBriefing) {
-      additions.push(wakeupBriefing);
-      delete (session as any)._wakeupBriefing; // Only inject once
+    // Wakeup briefing (synthesized at session start, may still be in-flight)
+    const wakeupPromise = (session as any)._wakeupPromise as Promise<string | null> | undefined;
+    if (wakeupPromise) {
+      const wakeupBriefing = await wakeupPromise;
+      delete (session as any)._wakeupPromise; // Only inject once
+      if (wakeupBriefing) additions.push(wakeupBriefing);
     }
 
     // Graduation celebration — tell the agent it just graduated so it can share with the user
@@ -340,7 +356,13 @@ export class KongBrainContextEngine implements ContextEngine {
     const session = this.state.getSession(sessionKey);
     if (!session) return;
 
-    const { store } = this.state;
+    const { store, embeddings } = this.state;
+
+    // Deferred cleanup: run once on first turn when complete() is available
+    if (session.userTurnCount <= 1 && typeof this.state.complete === "function") {
+      runDeferredCleanup(store, embeddings, this.state.complete)
+        .catch(e => swallow.warn("afterTurn:deferredCleanup", e));
+    }
 
     // Ingest new messages from this turn (OpenClaw skips ingest() when afterTurn exists)
     const newMessages = params.messages.slice(params.prePromptMessageCount);
@@ -381,11 +403,6 @@ export class KongBrainContextEngine implements ContextEngine {
       }, session, store, this.state.complete).catch(e => swallow.warn("afterTurn:cognitiveCheck", e));
     }
 
-    // Daemon batching — accumulate content tokens and flush when threshold met
-    if (session.lastAssistantText && hasSemantic(session.lastAssistantText)) {
-      session.newContentTokens += Math.ceil(session.lastAssistantText.length / 4);
-    }
-
     // Flush to daemon when token threshold OR turn count threshold is reached
     const tokenReady = session.newContentTokens >= session.DAEMON_TOKEN_THRESHOLD;
     const turnReady = session.userTurnCount >= session.lastDaemonFlushTurnCount + 3;
@@ -417,13 +434,84 @@ export class KongBrainContextEngine implements ContextEngine {
         swallow.warn("afterTurn:daemonBatch", e);
       }
     }
+
+    // Mid-session cleanup: simulate session_end after ~100k tokens.
+    // OpenClaw exits via Ctrl+C×2 (no async window), so session_end never fires.
+    // Run reflection, skill extraction, and causal graduation periodically.
+    const tokensSinceCleanup = session.cumulativeTokens - session.lastCleanupTokens;
+    if (tokensSinceCleanup >= session.MID_SESSION_CLEANUP_THRESHOLD && typeof this.state.complete === "function") {
+      session.lastCleanupTokens = session.cumulativeTokens;
+
+      // Fire-and-forget: these are non-critical background operations
+      const cleanupOps: Promise<unknown>[] = [];
+
+      // Final daemon flush with full transcript before cleanup
+      if (session.daemon) {
+        cleanupOps.push(
+          store.getSessionTurns(session.sessionId, 50)
+            .then(recentTurns => {
+              const turnData = recentTurns.map(t => ({
+                role: t.role as "user" | "assistant",
+                text: t.text,
+                turnId: (t as any).id,
+              }));
+              session.daemon!.sendTurnBatch(turnData, [...session.pendingThinking], []);
+            })
+            .catch(e => swallow.warn("midCleanup:daemonFlush", e)),
+        );
+      }
+
+      if (session.taskId) {
+        cleanupOps.push(
+          extractSkill(session.sessionId, session.taskId, store, embeddings, this.state.complete)
+            .catch(e => swallow.warn("midCleanup:extractSkill", e)),
+        );
+      }
+
+      cleanupOps.push(
+        generateReflection(session.sessionId, store, embeddings, this.state.complete)
+          .catch(e => swallow.warn("midCleanup:reflection", e)),
+      );
+
+      cleanupOps.push(
+        graduateCausalToSkills(store, embeddings, this.state.complete)
+          .catch(e => swallow.warn("midCleanup:graduateCausal", e)),
+      );
+
+      // Handoff note — snapshot for wakeup even if session continues
+      cleanupOps.push(
+        (async () => {
+          const recentTurns = await store.getSessionTurns(session.sessionId, 15);
+          if (recentTurns.length < 2) return;
+          const turnSummary = recentTurns
+            .map(t => `[${t.role}] ${t.text.slice(0, 200)}`)
+            .join("\n");
+          const handoffResponse = await this.state.complete({
+            system: "Summarize this session for handoff to your next self. What was worked on, what's unfinished, what to remember. 2-3 sentences. Write in first person.",
+            messages: [{ role: "user", content: turnSummary }],
+          });
+          const handoffText = handoffResponse.text.trim();
+          if (handoffText.length > 20) {
+            let embedding: number[] | null = null;
+            if (embeddings.isAvailable()) {
+              try { embedding = await embeddings.embed(handoffText); } catch { /* ok */ }
+            }
+            await store.createMemory(handoffText, embedding, 8, "handoff", session.sessionId);
+          }
+        })().catch(e => swallow.warn("midCleanup:handoff", e)),
+      );
+
+      // Don't await — let cleanup run in background
+      Promise.allSettled(cleanupOps).catch(() => {});
+    }
   }
 
   // ── Dispose ────────────────────────────────────────────────────────────
 
   async dispose(): Promise<void> {
-    // Phase 3: combined extraction, graduation, soul graduation
-    await this.state.shutdown();
+    // No-op: global state (store, embeddings, sessions) is shared across
+    // context engine instances and must NOT be destroyed here. OpenClaw
+    // creates a new context engine per turn and disposes the old one.
   }
 }
 

package/src/daemon-manager.ts

@@ -7,10 +7,10 @@
  * The extraction is I/O-bound (LLM calls + DB writes), not CPU-bound,
  * so in-process execution is fine.
  */
-import type { SurrealConfig, EmbeddingConfig } from "./config.js";
 import type { TurnData, PriorExtractions } from "./daemon-types.js";
-import { SurrealStore } from "./surreal.js";
-import { EmbeddingService } from "./embeddings.js";
+import type { CompleteFn } from "./state.js";
+import type { SurrealStore } from "./surreal.js";
+import type { EmbeddingService } from "./embeddings.js";
 import { swallow } from "./errors.js";
 
 export type { TurnData } from "./daemon-types.js";
@@ -32,16 +32,14 @@ export interface MemoryDaemon {
 }
 
 export function startMemoryDaemon(
-  surrealConfig: SurrealConfig,
-  embeddingConfig: EmbeddingConfig,
+  sharedStore: SurrealStore,
+  sharedEmbeddings: EmbeddingService,
   sessionId: string,
-  llmConfig?: { provider?: string; model?: string },
+  complete: CompleteFn,
 ): MemoryDaemon {
-  // Daemon-local DB and embedding instances (separate connections)
-  let store: SurrealStore | null = null;
-  let embeddings: EmbeddingService | null = null;
-  let initialized = false;
-  let initFailed = false;
+  // Use shared store/embeddings from global state (no duplicate connections)
+  const store = sharedStore;
+  const embeddings = sharedEmbeddings;
   let processing = false;
   let shuttingDown = false;
   let extractedTurnCount = 0;
@@ -51,24 +49,6 @@ export function startMemoryDaemon(
     conceptNames: [], artifactPaths: [], skillNames: [],
   };
 
-  // Lazy init — connect on first batch, not at startup
-  async function ensureInit(): Promise<boolean> {
-    if (initialized) return true;
-    if (initFailed) return false;
-    try {
-      store = new SurrealStore(surrealConfig);
-      await store.initialize();
-      embeddings = new EmbeddingService(embeddingConfig);
-      await embeddings.initialize();
-      initialized = true;
-      return true;
-    } catch (e) {
-      swallow.warn("daemon:init", e);
-      initFailed = true;
-      return false;
-    }
-  }
-
   // Import extraction logic lazily to avoid circular deps
   async function runExtraction(
     turns: TurnData[],
@@ -79,13 +59,6 @@ export function startMemoryDaemon(
     if (!store || !embeddings) return;
     if (turns.length < 2) return;
 
-    const provider = llmConfig?.provider;
-    const modelId = llmConfig?.model;
-    if (!provider || !modelId) {
-      swallow.warn("daemon:extraction", new Error("Missing llmProvider/llmModel"));
-      return;
-    }
-
     // Merge incoming prior state
     if (incomingPrior) {
       for (const name of incomingPrior.conceptNames) {
@@ -116,22 +89,12 @@ export function startMemoryDaemon(
 
     const systemPrompt = buildSystemPrompt(thinking.length > 0, retrievedMemories.length > 0, priorState);
 
-    const { completeSimple, getModel } = await import("@mariozechner/pi-ai");
-    const model = (getModel as any)(provider, modelId);
-
-    const response = await completeSimple(model, {
-      systemPrompt,
-      messages: [{
-        role: "user",
-        timestamp: Date.now(),
-        content: sections.join("\n\n"),
-      }],
+    const response = await complete({
+      system: systemPrompt,
+      messages: [{ role: "user", content: sections.join("\n\n") }],
     });
 
-    const responseText = response.content
-      .filter((c: any) => c.type === "text")
-      .map((c: any) => c.text)
-      .join("");
+    const responseText = response.text;
 
     const jsonMatch = responseText.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return;
@@ -188,10 +151,8 @@ export function startMemoryDaemon(
     sendTurnBatch(turns, thinking, retrievedMemories, priorExtractions) {
       if (shuttingDown) return;
       pendingBatch = { turns, thinking, retrievedMemories, priorExtractions };
-      // Fire-and-forget: init if needed, then process
-      ensureInit()
-        .then(ok => { if (ok) return processPending(); })
-        .catch(e => swallow.warn("daemon:sendBatch", e));
+      // Fire-and-forget
+      processPending().catch(e => swallow.warn("daemon:sendBatch", e));
     },
 
     async getStatus() {
@@ -216,13 +177,7 @@ export function startMemoryDaemon(
           new Promise<void>(resolve => setTimeout(resolve, timeoutMs)),
         ]);
       }
-      // Clean up daemon-local connections
-      await Promise.allSettled([
-        store?.dispose(),
-        embeddings?.dispose(),
-      ]).catch(() => {});
-      store = null;
-      embeddings = null;
+      // Shared store/embeddings — don't dispose (owned by global state)
     },
 
     getExtractedTurnCount() {

package/src/deferred-cleanup.ts

@@ -15,20 +15,49 @@ import { buildSystemPrompt, buildTranscript, writeExtractionResults } from "./me
 import type { PriorExtractions } from "./daemon-types.js";
 import { swallow } from "./errors.js";
 
+// Process-global flag — deferred cleanup runs AT MOST ONCE per process.
+// Using Symbol.for so it survives Jiti re-importing this module.
+const RAN_KEY = Symbol.for("kongbrain.deferredCleanup.ran");
+
 /**
  * Find and process orphaned sessions. Runs with a 30s total timeout.
  * Fire-and-forget from session_start — does not block the new session.
+ * Only runs once per process lifetime.
  */
 export async function runDeferredCleanup(
   store: SurrealStore,
   embeddings: EmbeddingService,
   complete: CompleteFn,
+): Promise<number> {
+  // Once per process — never re-run even if first run times out
+  if ((globalThis as any)[RAN_KEY]) return 0;
+  (globalThis as any)[RAN_KEY] = true;
+
+  try {
+    return await runDeferredCleanupInner(store, embeddings, complete);
+  } catch (e) {
+    swallow.warn("deferredCleanup:outer", e);
+    return 0;
+  }
+}
+
+async function runDeferredCleanupInner(
+  store: SurrealStore,
+  embeddings: EmbeddingService,
+  complete: CompleteFn,
 ): Promise<number> {
   if (!store.isAvailable()) return 0;
 
-  const orphaned = await store.getOrphanedSessions(3).catch(() => []);
+  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 () => {
@@ -42,10 +71,10 @@ export async function runDeferredCleanup(
     }
   };
 
-  // 30s timeout — don't hold up the new session forever
+  // 90s timeout — each session needs ~6s (2 LLM calls), 10 sessions ≈ 60s
   await Promise.race([
     cleanup(),
-    new Promise<void>(resolve => setTimeout(resolve, 30_000)),
+    new Promise<void>(resolve => setTimeout(resolve, 90_000)),
   ]);
 
   return processed;
@@ -57,25 +86,15 @@ async function processOrphanedSession(
   embeddings: EmbeddingService,
   complete: CompleteFn,
 ): Promise<void> {
-  // Find the OpenClaw session ID from turns stored in this session
-  // (turns use the OpenClaw session_id, not the surreal record ID)
-  const sessionTurns = await store.queryFirst<{ session_id: string }>(
-    `SELECT session_id FROM turn WHERE session_id != NONE ORDER BY created_at DESC LIMIT 1`,
-  ).catch(() => []);
-
-  // Load turns for extraction
-  // We need to find turns associated with this DB session via the part_of edge
+  // Load turns for extraction via part_of edges (turn->part_of->session)
   const turns = await store.queryFirst<{ role: string; text: string; tool_name?: string }>(
-    `SELECT role, text, tool_name FROM turn
-     WHERE session_id IN (SELECT VALUE out FROM part_of WHERE in = $sid)
-        OR session_id = $sid
+    `SELECT role, text, tool_name, created_at FROM turn
+     WHERE id IN (SELECT VALUE in FROM part_of WHERE out = $sid)
      ORDER BY created_at ASC LIMIT 50`,
     { sid: surrealSessionId },
   ).catch(() => []);
 
   if (turns.length < 2) {
-    // Nothing to extract, just mark complete
-    await store.markSessionEnded(surrealSessionId).catch(e => swallow("deferred:markEmpty", e));
     return;
   }
 
@@ -86,12 +105,14 @@ async function processOrphanedSession(
   const systemPrompt = buildSystemPrompt(false, false, priorState);
 
   try {
+    console.warn(`[deferred] extracting session ${surrealSessionId} (${turns.length} turns, transcript ${transcript.length} chars)`);
     const response = await complete({
       system: systemPrompt,
       messages: [{ role: "user", content: `[TRANSCRIPT]\n${transcript.slice(0, 60000)}` }],
     });
 
     const responseText = response.text;
+    console.warn(`[deferred] extraction response: ${responseText.length} chars`);
     const jsonMatch = responseText.match(/\{[\s\S]*\}/);
     if (jsonMatch) {
       let result: Record<string, any>;
@@ -103,10 +124,14 @@ async function processOrphanedSession(
         } catch { result = {}; }
       }
 
-      if (Object.keys(result).length > 0) {
-        const sessionId = surrealSessionId; // Use DB ID as session reference
-        await writeExtractionResults(result, sessionId, store, embeddings, priorState);
+      const keys = Object.keys(result);
+      console.warn(`[deferred] parsed ${keys.length} keys: ${keys.join(", ")}`);
+      if (keys.length > 0) {
+        await writeExtractionResults(result, surrealSessionId, store, embeddings, priorState);
+        console.warn(`[deferred] wrote extraction results for ${surrealSessionId}`);
       }
+    } else {
+      console.warn(`[deferred] no JSON found in response`);
     }
   } catch (e) {
     swallow.warn("deferredCleanup:extraction", e);
@@ -125,6 +150,7 @@ async function processOrphanedSession(
     });
 
     const handoffText = handoffResponse.text.trim();
+    console.warn(`[deferred] handoff response: ${handoffText.length} chars`);
     if (handoffText.length > 20) {
       let emb: number[] | null = null;
       if (embeddings.isAvailable()) {
@@ -135,7 +161,4 @@ async function processOrphanedSession(
   } catch (e) {
     swallow.warn("deferredCleanup:handoff", e);
   }
-
-  // Mark session as cleaned up
-  await store.markSessionEnded(surrealSessionId).catch(e => swallow("deferred:markDone", e));
 }

package/src/embeddings.ts

@@ -15,7 +15,9 @@ export class EmbeddingService {
 
   constructor(private readonly config: EmbeddingConfig) {}
 
-  async initialize(): Promise<void> {
+  /** Initialize the embedding model. Returns true if freshly loaded, false if already ready. */
+  async initialize(): Promise<boolean> {
+    if (this.ready) return false;
     if (!existsSync(this.config.modelPath)) {
       throw new Error(
         `Embedding model not found at: ${this.config.modelPath}\n  Download BGE-M3 GGUF or set EMBED_MODEL_PATH`,
@@ -33,6 +35,7 @@ export class EmbeddingService {
     this.model = await llama.loadModel({ modelPath: this.config.modelPath });
     this.ctx = await this.model.createEmbeddingContext();
     this.ready = true;
+    return true;
   }
 
   async embed(text: string): Promise<number[]> {

package/src/hooks/llm-output.ts

@@ -50,6 +50,7 @@ export function createLlmOutputHandler(state: GlobalPluginState) {
     // Accumulate for daemon batching (only when real tokens present)
     if (inputTokens + outputTokens > 0) {
       session.newContentTokens += inputTokens + outputTokens;
+      session.cumulativeTokens += inputTokens + outputTokens;
     }
 
     // Track accumulated text output for planning gate

package/src/index.ts

@@ -6,12 +6,13 @@
  */
 
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { parsePluginConfig } from "./config.js";
 import { SurrealStore } from "./surreal.js";
 import { EmbeddingService } from "./embeddings.js";
-import { GlobalPluginState } from "./state.js";
+import { GlobalPluginState, type CompleteFn } from "./state.js";
 import { KongBrainContextEngine } from "./context-engine.js";
 import { createRecallToolDef } from "./tools/recall.js";
 import { createCoreMemoryToolDef } from "./tools/core-memory.js";
@@ -22,7 +23,7 @@ import { createAfterToolCallHandler } from "./hooks/after-tool-call.js";
 import { createLlmOutputHandler } from "./hooks/llm-output.js";
 import { startMemoryDaemon } from "./daemon-manager.js";
 import { seedIdentity } from "./identity.js";
-import { synthesizeWakeup, synthesizeStartupCognition } from "./wakeup.js";
+import { synthesizeWakeup } from "./wakeup.js";
 import { extractSkill } from "./skills.js";
 import { generateReflection, setReflectionContextWindow } from "./reflection.js";
 import { graduateCausalToSkills } from "./skills.js";
@@ -32,11 +33,28 @@ import { writeHandoffFileSync } from "./handoff-file.js";
 import { runDeferredCleanup } from "./deferred-cleanup.js";
 import { swallow } from "./errors.js";
 
-let globalState: GlobalPluginState | null = null;
+// Use process-global symbols so state survives Jiti re-importing the module.
+// Jiti may load this file multiple times (fresh module scope each time),
+// but process.env and Symbol.for() are process-wide singletons.
+const GLOBAL_KEY = Symbol.for("kongbrain.globalState");
+const REGISTERED_KEY = Symbol.for("kongbrain.registered");
+
+function getGlobalState(): GlobalPluginState | null {
+  return (globalThis as any)[GLOBAL_KEY] ?? null;
+}
+function setGlobalState(state: GlobalPluginState): void {
+  (globalThis as any)[GLOBAL_KEY] = state;
+}
+function isRegistered(): boolean {
+  return (globalThis as any)[REGISTERED_KEY] === true;
+}
+function markRegistered(): void {
+  (globalThis as any)[REGISTERED_KEY] = true;
+}
+
 let shutdownPromise: Promise<void> | null = null;
 let registeredExitHandler: (() => void) | null = null;
 let registeredSyncExitHandler: (() => void) | null = null;
-let registered = false;
 
 /**
  * Run the critical session-end extraction for all active sessions.
@@ -294,13 +312,79 @@ export default definePluginEntry({
     const config = parsePluginConfig(api.pluginConfig as Record<string, unknown> | undefined);
     const logger = api.logger;
 
-    // Initialize shared resources — reuse existing globalState if register() is called
-    // multiple times (OpenClaw may invoke the factory more than once). Hooks from the
-    // first register() hold a closure over globalState, so replacing it would orphan them.
+    // Initialize shared resources — reuse existing state if register() is called
+    // multiple times (OpenClaw may invoke the factory more than once, and Jiti may
+    // re-import the module creating fresh module scope). Process-global symbols
+    // ensure a single instance survives across module reloads.
+    let globalState = getGlobalState();
     if (!globalState) {
       const store = new SurrealStore(config.surreal);
       const embeddings = new EmbeddingService(config.embedding);
-      globalState = new GlobalPluginState(config, store, embeddings, api.runtime.complete);
+      // Build a CompleteFn using pi-ai directly since api.runtime.complete
+      // is not available in OpenClaw 2026.3.24 (unreleased feature).
+      const apiRef = api;
+      // Resolve pi-ai from openclaw's node_modules. pi-ai is ESM-only so
+      // require() can't load it. Walk up from process.argv[1] to find it,
+      // then lazy-load via import() on first use.
+      let piAi: { getModel: any; completeSimple: any } | null = null;
+      let piAiPath: string | null = null;
+      {
+        let dir = dirname(process.argv[1] || __filename);
+        for (let i = 0; i < 10; i++) {
+          const candidate = join(dir, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js");
+          if (existsSync(candidate)) { piAiPath = candidate; break; }
+          const parent = dirname(dir);
+          if (parent === dir) break;
+          dir = parent;
+        }
+      }
+
+      const complete: CompleteFn = async (params) => {
+        // Try runtime.complete first (future-proof for when it ships)
+        if (typeof apiRef.runtime?.complete === "function") {
+          return apiRef.runtime.complete(params);
+        }
+        if (!piAi) {
+          if (!piAiPath) {
+            throw new Error("LLM completion not available: @mariozechner/pi-ai not found and runtime.complete missing");
+          }
+          piAi = await import(piAiPath);
+        }
+        // Fall back to calling pi-ai directly (runtime.complete not in OpenClaw 2026.3.24)
+        const provider = params.provider ?? apiRef.runtime.agent.defaults.provider;
+        const modelId = params.model ?? apiRef.runtime.agent.defaults.model;
+        const model = piAi!.getModel(provider, modelId);
+        if (!model) {
+          throw new Error(`Model "${modelId}" not found for provider "${provider}"`);
+        }
+        // Resolve auth via OpenClaw's runtime (handles profiles, env vars, etc.)
+        const cfg = apiRef.runtime.config.loadConfig();
+        const auth = await apiRef.runtime.modelAuth.getApiKeyForModel({ model, cfg });
+        // Build context
+        const now = Date.now();
+        const messages: any[] = params.messages.map(m =>
+          m.role === "user"
+            ? { role: "user", content: m.content, timestamp: now }
+            : { role: "assistant", content: [{ type: "text", text: m.content }],
+                api: model.api, provider: model.provider, model: model.id,
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+                stopReason: "stop", timestamp: now }
+        );
+        const context = { systemPrompt: params.system, messages };
+        // Pass apiKey directly in options so the provider can use it
+        const response = await piAi!.completeSimple(model, context, {
+          apiKey: auth.apiKey,
+        });
+        let text = "";
+        let thinking: string | undefined;
+        for (const block of response.content) {
+          if (block.type === "text") text += block.text;
+          else if ((block as any).type === "thinking") thinking = (thinking ?? "") + (block as any).thinking;
+        }
+        return { text, thinking, usage: { input: response.usage.input, output: response.usage.output } };
+      };
+      globalState = new GlobalPluginState(config, store, embeddings, complete);
+      setGlobalState(globalState);
     }
     globalState.workspaceDir = api.resolvePath(".");
     globalState.enqueueSystemEvent = (text, opts) =>
@@ -312,19 +396,19 @@ export default definePluginEntry({
     api.registerContextEngine("kongbrain", async () => {
       const { store, embeddings } = state;
 
-      // Connect to SurrealDB
+      // Connect to SurrealDB (no-op if already connected)
       try {
-        await store.initialize();
-        logger.info(`SurrealDB connected: ${config.surreal.url}`);
+        const freshConnect = await store.initialize();
+        if (freshConnect) logger.info(`SurrealDB connected: ${config.surreal.url}`);
       } catch (e) {
         logger.error(`SurrealDB connection failed: ${e}`);
         throw e;
       }
 
-      // Initialize BGE-M3 embeddings
+      // Initialize BGE-M3 embeddings (no-op if already loaded)
       try {
-        await embeddings.initialize();
-        logger.info(`BGE-M3 embeddings initialized: ${config.embedding.modelPath}`);
+        const freshEmbed = await embeddings.initialize();
+        if (freshEmbed) logger.info(`BGE-M3 embeddings initialized: ${config.embedding.modelPath}`);
       } catch (e) {
         logger.warn(`Embeddings init failed — running in degraded mode: ${e}`);
       }
@@ -339,7 +423,7 @@ export default definePluginEntry({
 
     // ── Hook handlers (register once — register() may be called multiple times) ──
 
-    if (!registered) {
+    if (!isRegistered()) {
       api.on("before_prompt_build", createBeforePromptBuildHandler(globalState));
       api.on("before_tool_call", createBeforeToolCallHandler(globalState));
       api.on("after_tool_call", createAfterToolCallHandler(globalState));
@@ -348,7 +432,8 @@ export default definePluginEntry({
 
     // ── Session lifecycle (also register once) ─────────────────────────
 
-    if (!registered) api.on("session_start", async (event) => {
+    if (!isRegistered()) api.on("session_start", async (event) => {
+      const globalState = getGlobalState();
       if (!globalState) return;
       const sessionKey = event.sessionKey ?? event.sessionId;
       const session = globalState.getOrCreateSession(sessionKey, event.sessionId);
@@ -374,10 +459,10 @@ export default definePluginEntry({
       // Start memory daemon worker thread
       try {
         session.daemon = startMemoryDaemon(
-          config.surreal,
-          config.embedding,
+          globalState!.store,
+          globalState!.embeddings,
           session.sessionId,
-          { provider: api.runtime.agent.defaults.provider, model: api.runtime.agent.defaults.model },
+          globalState!.complete,
         );
       } catch (e) {
         swallow.warn("index:startDaemon", e);
@@ -398,31 +483,22 @@ export default definePluginEntry({
       setReflectionContextWindow(200000);
 
       // Check for recent graduation event (from a previous session)
-      detectGraduationEvent(store, session, globalState!)
+      detectGraduationEvent(globalState!.store, session, globalState!)
         .catch(e => swallow("index:graduationDetect", e));
 
-      // Synthesize wakeup briefing (background, non-blocking)
-      // The briefing is stored and later injected via assemble()'s systemPromptAddition
-      synthesizeWakeup(store, globalState!.complete, session.sessionId, globalState!.workspaceDir)
-        .then(briefing => {
-          if (briefing) (session as any)._wakeupBriefing = briefing;
-        })
-        .catch(e => swallow.warn("index:wakeup", e));
-
-      // Startup cognition (background)
-      synthesizeStartupCognition(store, globalState!.complete)
-        .then(cognition => {
-          if (cognition) (session as any)._startupCognition = cognition;
-        })
-        .catch(e => swallow.warn("index:startupCognition", e));
+      // Synthesize wakeup briefing — store the promise so assemble() can await it
+      (session as any)._wakeupPromise = synthesizeWakeup(
+        globalState!.store, globalState!.complete, session.sessionId, globalState!.workspaceDir,
+      ).catch(e => { swallow.warn("index:wakeup", e); return null; });
 
       // Deferred cleanup: extract knowledge from orphaned sessions (background)
-      runDeferredCleanup(store, embeddings, globalState!.complete)
+      runDeferredCleanup(globalState!.store, globalState!.embeddings, globalState!.complete)
         .then(n => { if (n > 0) logger.info(`Deferred cleanup: processed ${n} orphaned session(s)`); })
         .catch(e => swallow.warn("index:deferredCleanup", e));
     });
 
-    if (!registered) api.on("session_end", async (event) => {
+    if (!isRegistered()) api.on("session_end", async (event) => {
+      const globalState = getGlobalState();
       if (!globalState) return;
       const sessionKey = event.sessionKey ?? event.sessionId;
       const session = globalState.getSession(sessionKey);
@@ -434,7 +510,7 @@ export default definePluginEntry({
 
       session.cleanedUp = true;
       if (session.surrealSessionId) {
-        await store.markSessionEnded(session.surrealSessionId)
+        await globalState.store.markSessionEnded(session.surrealSessionId)
           .catch(e => swallow.warn("session_end:markEnded", e));
       }
 
@@ -458,8 +534,9 @@ export default definePluginEntry({
 
     // Sync exit handler: writes handoff file for all uncleaned sessions
     const syncExitHandler = () => {
-      if (!globalState?.workspaceDir) return;
-      const sessions = [...(globalState as any).sessions.values()] as import("./state.js").SessionState[];
+      const gs = getGlobalState();
+      if (!gs?.workspaceDir) return;
+      const sessions = [...(gs as any).sessions.values()] as import("./state.js").SessionState[];
       for (const session of sessions) {
         if (session.cleanedUp) continue;
         writeHandoffFileSync({
@@ -469,21 +546,22 @@ export default definePluginEntry({
           lastUserText: session.lastUserText.slice(0, 500),
           lastAssistantText: session.lastAssistantText.slice(0, 500),
           unextractedTokens: session.newContentTokens,
-        }, globalState!.workspaceDir!);
+        }, gs.workspaceDir!);
       }
     };
 
     // Async exit handler: full cleanup for SIGTERM (gateway/daemon mode)
     const asyncExitHandler = () => {
-      if (!globalState) return;
-      const sessions = [...(globalState as any).sessions.values()] as import("./state.js").SessionState[];
+      const gs = getGlobalState();
+      if (!gs) return;
+      const sessions = [...(gs as any).sessions.values()] as import("./state.js").SessionState[];
       if (sessions.length === 0 && !shutdownPromise) return;
 
-      const cleanups = sessions.map(s => runSessionCleanup(s, globalState!));
+      const cleanups = sessions.map(s => runSessionCleanup(s, gs));
       if (shutdownPromise) cleanups.push(shutdownPromise);
 
       const done = Promise.allSettled(cleanups).then(() => {
-        globalState?.shutdown().catch(() => {});
+        gs.shutdown().catch(() => {});
       });
 
       done.then(() => process.exit(0)).catch(() => process.exit(1));
@@ -494,9 +572,6 @@ export default definePluginEntry({
     process.on("exit", syncExitHandler);
     process.once("SIGTERM", asyncExitHandler);
 
-    if (!registered) {
-      logger.info("KongBrain plugin registered");
-      registered = true;
-    }
+    markRegistered();
   },
 });

package/src/memory-daemon.ts

@@ -37,11 +37,12 @@ ${dedup}
     // Only when there's a clear trigger and outcome. Max 5.
     {"triggerText": "what caused it (max 200 chars)", "outcomeText": "what happened as a result", "chainType": "debug|refactor|feature|fix", "success": true/false, "confidence": 0.0-1.0, "description": "1-sentence summary"}
   ],
-${hasThinking ? `  "monologue": [
+  "monologue": [
     // Internal reasoning moments worth preserving: doubts, tradeoffs, insights, realizations.
+    // Infer from the conversation flow — approach changes, surprising discoveries, tradeoff decisions.
     // Skip routine reasoning. Only novel/surprising thoughts. Max 5.
     {"category": "doubt|tradeoff|alternative|insight|realization", "content": "1-2 sentence description"}
-  ],` : '  "monologue": [],'}
+  ],
 ${hasRetrievedMemories ? `  "resolved": [
     // IDs from [RETRIEVED MEMORIES] that have been FULLY addressed/fixed/completed in this conversation.
     // Must be exact IDs like "memory:abc123". Empty [] if none resolved.

package/src/reflection.ts

@@ -140,30 +140,31 @@ export async function generateReflection(
   embeddings: EmbeddingService,
   complete: CompleteFn,
 ): Promise<void> {
-  const metrics = await gatherSessionMetrics(sessionId, store);
-  if (!metrics) return;
+  if (!store.isAvailable()) return;
 
-  const { reflect, reasons } = shouldReflect(metrics);
-  if (!reflect) return;
+  // Get session turns directly — no dependency on orchestrator_metrics
+  const turns = await store.getSessionTurns(sessionId, 30).catch(() => []);
+  if (turns.length < 3) return; // Too short for meaningful reflection
 
-  const severity = reasons.length >= 3 ? "critical" : reasons.length >= 2 ? "moderate" : "minor";
+  const transcript = turns
+    .map(t => `[${t.role}] ${(t.text ?? "").slice(0, 300)}`)
+    .join("\n");
 
-  let category = "efficiency";
-  if (metrics.toolFailureRate > TOOL_FAILURE_THRESHOLD) category = "failure_pattern";
-  if (metrics.steeringCandidates >= STEERING_THRESHOLD) category = "approach_strategy";
+  const severity = turns.length >= 15 ? "moderate" : "minor";
+  const category = "session_review";
 
   try {
     const response = await complete({
-      system: `Write 2-4 sentences: root cause, error pattern, what to do differently. Be specific. Example: "Spent 8 tool calls reading source before checking error log. For timeout bugs, check logs first."`,
+      system: `Reflect on this session. Write 2-4 sentences about: what went well, what could improve, any patterns worth noting. Be specific and actionable. If the session was too trivial for reflection, respond with just "skip".`,
       messages: [{
         role: "user",
-        content: `${metrics.totalTurns} turns, ${metrics.totalToolCalls} tools, ${(metrics.avgUtilization * 100).toFixed(0)}% util, ${(metrics.toolFailureRate * 100).toFixed(0)}% fail, ~${metrics.wastedTokens} wasted tokens\nIssues: ${reasons.join("; ")}`,
+        content: `Session with ${turns.length} turns:\n${transcript.slice(0, 15000)}`,
       }],
     });
 
     const reflectionText = response.text.trim();
 
-    if (reflectionText.length < 20) return;
+    if (reflectionText.length < 20 || reflectionText.toLowerCase() === "skip") return;
 
     let reflEmb: number[] | null = null;
     if (embeddings.isAvailable()) {

package/src/schema.surql

@@ -375,15 +375,6 @@ DEFINE FIELD IF NOT EXISTS created_at ON graduation_event TYPE datetime DEFAULT
 -- ============================================================
 -- MIGRATIONS (must run after table definitions)
 -- ============================================================
--- Drop old 768d HNSW indexes (now 1024d with BGE-M3)
-REMOVE INDEX IF EXISTS turn_vec_idx ON turn;
-REMOVE INDEX IF EXISTS identity_vec_idx ON identity_chunk;
-REMOVE INDEX IF EXISTS concept_vec_idx ON concept;
-REMOVE INDEX IF EXISTS memory_vec_idx ON memory;
-REMOVE INDEX IF EXISTS artifact_vec_idx ON artifact;
--- Clear stale 768d embeddings (incompatible with new 1024d model)
-UPDATE turn SET embedding = NONE WHERE embedding != NONE AND array::len(embedding) = 768;
-UPDATE identity_chunk SET embedding = NONE WHERE embedding != NONE AND array::len(embedding) = 768;
-UPDATE concept SET embedding = NONE WHERE embedding != NONE AND array::len(embedding) = 768;
-UPDATE memory SET embedding = NONE WHERE embedding != NONE AND array::len(embedding) = 768;
-UPDATE artifact SET embedding = NONE WHERE embedding != NONE AND array::len(embedding) = 768;
+-- 768d → 1024d migration completed; REMOVE INDEX / UPDATE stale
+-- embeddings removed to avoid destroying live HNSW indexes on
+-- every startup.

package/src/skills.ts

@@ -60,17 +60,8 @@ export async function extractSkill(
 ): Promise<string | null> {
   if (!store.isAvailable()) return null;
 
-  // Check if session had enough tool activity
-  const metricsRows = await store.queryFirst<{ totalTools: number }>(
-    `SELECT math::sum(actual_tool_calls) AS totalTools
-     FROM orchestrator_metrics WHERE session_id = $sid GROUP ALL`,
-    { sid: sessionId },
-  ).catch(() => [] as { totalTools: number }[]);
-  const totalTools = Number(metricsRows[0]?.totalTools ?? 0);
-  if (totalTools < 3) return null;
-
   const turns = await store.getSessionTurns(sessionId, 50);
-  if (turns.length < 4) return null;
+  if (turns.length < 4) return null; // Too short for skill extraction
 
   const transcript = turns
     .map((t) => `[${t.role}] ${(t.text ?? "").slice(0, 300)}`)
@@ -81,7 +72,7 @@ export async function extractSkill(
       system: `Return JSON or null. Fields: {name, description, preconditions, steps: [{tool, description}] (max 8), postconditions}. Generic patterns only (no specific paths). null if no clear multi-step workflow.`,
       messages: [{
         role: "user",
-        content: `${totalTools} tool calls:\n${transcript.slice(0, 20000)}`,
+        content: `${turns.length} turns:\n${transcript.slice(0, 20000)}`,
       }],
     });
 

package/src/soul.ts

@@ -36,7 +36,6 @@ export interface GraduationSignals {
   reflections: number;
   causalChains: number;
   concepts: number;
-  memoryCompactions: number;
   monologues: number;
   spanDays: number;
 }
@@ -91,7 +90,6 @@ const THRESHOLDS: GraduationSignals = {
   reflections: 10,
   causalChains: 5,
   concepts: 30,
-  memoryCompactions: 5,
   monologues: 5,
   spanDays: 3,
 };
@@ -104,17 +102,16 @@ const QUALITY_GATE = 0.6;
 async function getGraduationSignals(store: SurrealStore): Promise<GraduationSignals> {
   const defaults: GraduationSignals = {
     sessions: 0, reflections: 0, causalChains: 0,
-    concepts: 0, memoryCompactions: 0, monologues: 0, spanDays: 0,
+    concepts: 0, monologues: 0, spanDays: 0,
   };
   if (!store.isAvailable()) return defaults;
 
   try {
-    const [sessions, reflections, causal, concepts, compactions, monologues, span] = await Promise.all([
+    const [sessions, reflections, causal, concepts, monologues, span] = await Promise.all([
       store.queryFirst<{ count: number }>(`SELECT count() AS count FROM session GROUP ALL`).catch(() => []),
       store.queryFirst<{ count: number }>(`SELECT count() AS count FROM reflection GROUP ALL`).catch(() => []),
       store.queryFirst<{ count: number }>(`SELECT count() AS count FROM causal_chain GROUP ALL`).catch(() => []),
       store.queryFirst<{ count: number }>(`SELECT count() AS count FROM concept GROUP ALL`).catch(() => []),
-      store.queryFirst<{ count: number }>(`SELECT count() AS count FROM compaction_checkpoint WHERE status = "complete" GROUP ALL`).catch(() => []),
       store.queryFirst<{ count: number }>(`SELECT count() AS count FROM monologue GROUP ALL`).catch(() => []),
       store.queryFirst<{ earliest: string }>(`SELECT started_at AS earliest FROM session ORDER BY started_at ASC LIMIT 1`).catch(() => []),
     ]);
@@ -130,7 +127,6 @@ async function getGraduationSignals(store: SurrealStore): Promise<GraduationSign
       reflections: (reflections as { count: number }[])[0]?.count ?? 0,
       causalChains: (causal as { count: number }[])[0]?.count ?? 0,
       concepts: (concepts as { count: number }[])[0]?.count ?? 0,
-      memoryCompactions: (compactions as { count: number }[])[0]?.count ?? 0,
       monologues: (monologues as { count: number }[])[0]?.count ?? 0,
       spanDays,
     };
@@ -358,7 +354,6 @@ function getSuggestion(key: keyof GraduationSignals, current: number, threshold:
     case "reflections": return `${remaining} more reflection(s) needed. These are generated automatically when sessions have performance issues.`;
     case "causalChains": return `${remaining} more causal chain(s) needed. These form when the agent corrects mistakes during tool usage.`;
     case "concepts": return `${remaining} more concept(s) needed. Concepts are extracted from conversation topics and domain vocabulary.`;
-    case "memoryCompactions": return `${remaining} more compaction(s) needed. These happen during longer sessions with substantial context.`;
     case "monologues": return `${remaining} more monologue(s) needed. Inner monologue triggers during cognitive checks.`;
     case "spanDays": return `${remaining} more day(s) of history needed. The agent needs time-spread experience, not just volume.`;
   }

package/src/state.ts

@@ -1,12 +1,32 @@
-import type { PluginCompleteParams, PluginCompleteResult } from "openclaw/plugin-sdk";
 import type { KongBrainConfig } from "./config.js";
 import type { SurrealStore } from "./surreal.js";
 import type { EmbeddingService } from "./embeddings.js";
 import type { AdaptiveConfig } from "./orchestrator.js";
 import type { MemoryDaemon } from "./daemon-manager.js";
 
+/** Parameters for an LLM completion call. */
+export type CompleteParams = {
+  system?: string;
+  messages: { role: "user" | "assistant"; content: string }[];
+  provider?: string;
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  reasoning?: "none" | "low" | "medium" | "high";
+};
+
+/** Result of an LLM completion call. */
+export type CompleteResult = {
+  text: string;
+  thinking?: string;
+  usage?: { input: number; output: number };
+  provider?: string;
+  model?: string;
+  stopReason?: string;
+};
+
 /** Provider-agnostic LLM completion function. */
-export type CompleteFn = (params: PluginCompleteParams) => Promise<PluginCompleteResult>;
+export type CompleteFn = (params: CompleteParams) => Promise<CompleteResult>;
 
 // --- Per-session mutable state ---
 
@@ -37,6 +57,11 @@ export class SessionState {
   readonly DAEMON_TOKEN_THRESHOLD = 4000;
   lastDaemonFlushTurnCount = 0;
 
+  // Cumulative session token tracking (for mid-session cleanup trigger)
+  cumulativeTokens = 0;
+  lastCleanupTokens = 0;
+  readonly MID_SESSION_CLEANUP_THRESHOLD = 100_000;
+
   // Cleanup tracking
   cleanedUp = false;
 
@@ -78,7 +103,7 @@ export class GlobalPluginState {
   readonly config: KongBrainConfig;
   readonly store: SurrealStore;
   readonly embeddings: EmbeddingService;
-  readonly complete: CompleteFn;
+  complete: CompleteFn;
   workspaceDir?: string;
   enqueueSystemEvent?: EnqueueSystemEventFn;
   private sessions = new Map<string, SessionState>();

package/src/surreal.ts

@@ -105,19 +105,28 @@ export class SurrealStore {
   private config: SurrealConfig;
   private reconnecting: Promise<void> | null = null;
   private shutdownFlag = false;
+  private initialized = false;
 
   constructor(config: SurrealConfig) {
     this.config = config;
     this.db = new Surreal();
   }
 
-  async initialize(): Promise<void> {
+  /** Connect and run schema. Returns true if a new connection was made, false if already initialized. */
+  async initialize(): Promise<boolean> {
+    // Only connect once — subsequent calls are no-ops.
+    // This prevents register()/factory re-invocations from disrupting
+    // in-flight operations (deferred cleanup, daemon extraction).
+    // Don't check isConnected — ensureConnected() handles reconnection.
+    if (this.initialized) return false;
     await this.db.connect(this.config.url, {
       namespace: this.config.ns,
       database: this.config.db,
       authentication: { username: this.config.user, password: this.config.pass },
     });
     await this.runSchema();
+    this.initialized = true;
+    return true;
   }
 
   markShutdown(): void {
@@ -218,16 +227,43 @@ export class SurrealStore {
     }
   }
 
+  /** Returns true if an error is a connection-level failure worth retrying. */
+  private isConnectionError(e: unknown): boolean {
+    const msg = String((e as any)?.message ?? e);
+    return msg.includes("must be connected") || msg.includes("ConnectionUnavailable");
+  }
+
+  /** Run a query function with one retry on connection errors. */
+  private async withRetry<T>(fn: () => Promise<T>): Promise<T> {
+    try {
+      return await fn();
+    } catch (e) {
+      if (!this.isConnectionError(e)) throw e;
+      // Connection died — force a fresh connection (close stale socket first)
+      this.initialized = false;
+      try { await this.db?.close(); } catch { /* ignore */ }
+      this.db = new Surreal();
+      await this.db.connect(this.config.url, {
+        namespace: this.config.ns,
+        database: this.config.db,
+        authentication: { username: this.config.user, password: this.config.pass },
+      });
+      return await fn();
+    }
+  }
+
   // ── Query helpers ──────────────────────────────────────────────────────
 
   async queryFirst<T>(sql: string, bindings?: Record<string, unknown>): Promise<T[]> {
     await this.ensureConnected();
-    const ns = this.config.ns;
-    const dbName = this.config.db;
-    const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
-    const result = await this.db.query<[T[]]>(fullSql, bindings);
-    const rows = Array.isArray(result) ? result[result.length - 1] : result;
-    return (Array.isArray(rows) ? rows : []).filter(Boolean);
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
+      const result = await this.db.query<[T[]]>(fullSql, bindings);
+      const rows = Array.isArray(result) ? result[result.length - 1] : result;
+      return (Array.isArray(rows) ? rows : []).filter(Boolean);
+    });
   }
 
   async queryMulti<T = unknown>(
@@ -235,20 +271,24 @@ export class SurrealStore {
     bindings?: Record<string, unknown>,
   ): Promise<T | undefined> {
     await this.ensureConnected();
-    const ns = this.config.ns;
-    const dbName = this.config.db;
-    const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
-    const raw = await this.db.query(fullSql, bindings);
-    const flat = (raw as unknown[]).flat();
-    return flat[flat.length - 1] as T | undefined;
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
+      const raw = await this.db.query(fullSql, bindings);
+      const flat = (raw as unknown[]).flat();
+      return flat[flat.length - 1] as T | undefined;
+    });
   }
 
   async queryExec(sql: string, bindings?: Record<string, unknown>): Promise<void> {
     await this.ensureConnected();
-    const ns = this.config.ns;
-    const dbName = this.config.db;
-    const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
-    await this.db.query(fullSql, bindings);
+    return this.withRetry(async () => {
+      const ns = this.config.ns;
+      const dbName = this.config.db;
+      const fullSql = `USE NS ${ns} DB ${dbName}; ${patchOrderByFields(sql)}`;
+      await this.db.query(fullSql, bindings);
+    });
   }
 
   private async safeQuery(
@@ -884,7 +924,8 @@ export class SurrealStore {
         timestamp: string;
       }>(
         `SELECT role, text, tool_name, timestamp FROM turn
-         WHERE session_id = $sid AND text != NONE AND text != ""
+         WHERE id IN (SELECT VALUE in FROM part_of WHERE out = $sid)
+           AND text != NONE AND text != ""
          ORDER BY timestamp DESC LIMIT $lim`,
         { sid: prevSessionId, lim: limit },
       );

package/src/tools/recall.ts

@@ -41,7 +41,7 @@ export function createRecallToolDef(state: GlobalPluginState, session: SessionSt
         const scope = params.scope ?? "all";
 
         if (scope === "skills") {
-          const skills = await findRelevantSkills(queryVec, maxResults);
+          const skills = await findRelevantSkills(queryVec, maxResults, store);
           if (skills.length === 0) {
             return { content: [{ type: "text" as const, text: `No skills found matching "${params.query}".` }], details: null };
           }