kongbrain 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.2.0",
+  "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/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";
@@ -46,6 +47,9 @@ 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));
@@ -88,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)
@@ -156,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
@@ -389,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;
@@ -425,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,11 +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 type { CompleteFn } from "./state.js";
-import { SurrealStore } from "./surreal.js";
-import { EmbeddingService } from "./embeddings.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";
@@ -33,16 +32,14 @@ export interface MemoryDaemon {
 }
 
 export function startMemoryDaemon(
-  surrealConfig: SurrealConfig,
-  embeddingConfig: EmbeddingConfig,
+  sharedStore: SurrealStore,
+  sharedEmbeddings: EmbeddingService,
   sessionId: 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;
@@ -52,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[],
@@ -172,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() {
@@ -200,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/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

@@ -23,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";
@@ -459,8 +459,8 @@ export default definePluginEntry({
       // Start memory daemon worker thread
       try {
         session.daemon = startMemoryDaemon(
-          config.surreal,
-          config.embedding,
+          globalState!.store,
+          globalState!.embeddings,
           session.sessionId,
           globalState!.complete,
         );
@@ -486,20 +486,10 @@ export default definePluginEntry({
       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(globalState!.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(globalState!.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(globalState!.store, globalState!.embeddings, globalState!.complete)

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

@@ -57,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;
 

package/src/surreal.ts

@@ -924,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 };
           }