kongbrain 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.2.0",
+  "version": "0.3.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

@@ -282,8 +282,9 @@ function trainInBackground(
 const STALENESS_GROWTH_FACTOR = 0.5;
 const STALENESS_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
-export async function checkACANReadiness(store?: SurrealStore): Promise<void> {
+export async function checkACANReadiness(store?: SurrealStore, trainingThreshold?: number): Promise<void> {
   if (!store) return;
+  const threshold = trainingThreshold ?? TRAINING_THRESHOLD;
   const weightsPath = join(getKongDir(), WEIGHTS_FILENAME);
   const hasWeights = initACAN();
   const count = await getTrainingDataCount(store);
@@ -295,13 +296,13 @@ export async function checkACANReadiness(store?: SurrealStore): Promise<void> {
     const ageMs = Date.now() - trainedAt;
     const isStale = growthRatio >= STALENESS_GROWTH_FACTOR || ageMs >= STALENESS_MAX_AGE_MS;
     if (!isStale) return;
-  } else if (count < TRAINING_THRESHOLD) {
+  } else if (count < threshold) {
     return;
   }
 
   try {
     const samples = await fetchTrainingData(store);
-    if (samples.length < TRAINING_THRESHOLD) return;
+    if (samples.length < threshold) return;
     trainInBackground(samples, weightsPath, hasWeights ? _weights ?? undefined : undefined);
   } catch {
     // training is best-effort

package/src/config.ts

@@ -15,9 +15,23 @@ export interface EmbeddingConfig {
   dimensions: number;
 }
 
+export interface ThresholdConfig {
+  /** Tokens accumulated before daemon flushes extraction (default: 4000) */
+  daemonTokenThreshold: number;
+  /** Cumulative tokens before mid-session cleanup fires (default: 100000) */
+  midSessionCleanupThreshold: number;
+  /** Per-extraction timeout in ms (default: 60000) */
+  extractionTimeoutMs: number;
+  /** Max pending thinking blocks kept in memory (default: 20) */
+  maxPendingThinking: number;
+  /** Retrieval outcome samples needed before ACAN training (default: 5000) */
+  acanTrainingThreshold: number;
+}
+
 export interface KongBrainConfig {
   surreal: SurrealConfig;
   embedding: EmbeddingConfig;
+  thresholds: ThresholdConfig;
 }
 
 /**
@@ -27,6 +41,7 @@ export interface KongBrainConfig {
 export function parsePluginConfig(raw?: Record<string, unknown>): KongBrainConfig {
   const surreal = (raw?.surreal ?? {}) as Record<string, unknown>;
   const embedding = (raw?.embedding ?? {}) as Record<string, unknown>;
+  const thresholds = (raw?.thresholds ?? {}) as Record<string, unknown>;
 
   // Priority: plugin config > env vars > defaults
   const url =
@@ -60,5 +75,17 @@ export function parsePluginConfig(raw?: Record<string, unknown>): KongBrainConfi
       dimensions:
         typeof embedding.dimensions === "number" ? embedding.dimensions : 1024,
     },
+    thresholds: {
+      daemonTokenThreshold:
+        typeof thresholds.daemonTokenThreshold === "number" ? thresholds.daemonTokenThreshold : 4000,
+      midSessionCleanupThreshold:
+        typeof thresholds.midSessionCleanupThreshold === "number" ? thresholds.midSessionCleanupThreshold : 100_000,
+      extractionTimeoutMs:
+        typeof thresholds.extractionTimeoutMs === "number" ? thresholds.extractionTimeoutMs : 60_000,
+      maxPendingThinking:
+        typeof thresholds.maxPendingThinking === "number" ? thresholds.maxPendingThinking : 20,
+      acanTrainingThreshold:
+        typeof thresholds.acanTrainingThreshold === "number" ? thresholds.acanTrainingThreshold : 5000,
+    },
   };
 }

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));
@@ -69,51 +73,64 @@ export class KongBrainContextEngine implements ContextEngine {
   }): Promise<BootstrapResult> {
     const { store, embeddings } = this.state;
 
-    // Run schema if first bootstrap
-    try {
-      const schemaPath = join(__dirname, "..", "src", "schema.surql");
-      let schemaSql: string;
+    // Run schema once per process (idempotent but expensive on every bootstrap)
+    if (!this.state.schemaApplied) {
       try {
-        schemaSql = readFileSync(schemaPath, "utf-8");
-      } catch {
-        // Fallback: try relative to compiled output
-        schemaSql = readFileSync(join(__dirname, "schema.surql"), "utf-8");
+        const schemaPath = join(__dirname, "..", "src", "schema.surql");
+        let schemaSql: string;
+        try {
+          schemaSql = readFileSync(schemaPath, "utf-8");
+        } catch {
+          // Fallback: try relative to compiled output
+          schemaSql = readFileSync(join(__dirname, "schema.surql"), "utf-8");
+        }
+        await store.queryExec(schemaSql);
+        this.state.schemaApplied = true;
+      } catch (e) {
+        swallow.warn("context-engine:schema", e);
       }
-      await store.queryExec(schemaSql);
-    } catch (e) {
-      swallow.warn("context-engine:schema", e);
     }
 
     // 5-pillar graph init
     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,
+            this.state.config.thresholds.extractionTimeoutMs,
+          );
+        }
+      } catch (e) {
+        swallow.error("bootstrap:5pillar", e);
+      }
     }
 
     // Background maintenance (non-blocking)
@@ -122,7 +139,7 @@ export class KongBrainContextEngine implements ContextEngine {
       store.archiveOldTurns(),
       store.consolidateMemories((text) => embeddings.embed(text)),
       store.garbageCollectMemories(),
-      checkACANReadiness(store),
+      checkACANReadiness(store, this.state.config.thresholds.acanTrainingThreshold),
       // Deferred cleanup is triggered on first afterTurn() when complete() is available
     ]).catch(e => swallow.warn("bootstrap:maintenance", e));
 
@@ -156,11 +173,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,13 +407,8 @@ 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 tokenReady = session.newContentTokens >= session.daemonTokenThreshold;
     const turnReady = session.userTurnCount >= session.lastDaemonFlushTurnCount + 3;
     if (session.daemon && (tokenReady || turnReady)) {
       try {
@@ -425,13 +438,90 @@ 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.midSessionCleanupThreshold && 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)),
+      );
+
+      // ACAN: check if new retrieval outcomes warrant retraining
+      cleanupOps.push(
+        checkACANReadiness(store, this.state.config.thresholds.acanTrainingThreshold)
+          .catch(e => swallow("midCleanup:acan", 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,15 @@ export interface MemoryDaemon {
 }
 
 export function startMemoryDaemon(
-  surrealConfig: SurrealConfig,
-  embeddingConfig: EmbeddingConfig,
+  sharedStore: SurrealStore,
+  sharedEmbeddings: EmbeddingService,
   sessionId: string,
   complete: CompleteFn,
+  extractionTimeoutMs = 60_000,
 ): 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 +50,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[],
@@ -158,7 +138,12 @@ export function startMemoryDaemon(
       const batch = pendingBatch;
       pendingBatch = null;
       try {
-        await runExtraction(batch.turns, batch.thinking, batch.retrievedMemories, batch.priorExtractions);
+        await Promise.race([
+          runExtraction(batch.turns, batch.thinking, batch.retrievedMemories, batch.priorExtractions),
+          new Promise<void>((_, reject) =>
+            setTimeout(() => reject(new Error(`Extraction timed out after ${extractionTimeoutMs}ms`)), extractionTimeoutMs),
+          ),
+        ]);
       } catch (e) {
         errorCount++;
         swallow.warn("daemon:extraction", e);
@@ -172,10 +157,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 +183,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/embeddings.ts

@@ -11,7 +11,6 @@ export class EmbeddingService {
   private model: LlamaModel | null = null;
   private ctx: LlamaEmbeddingContext | null = null;
   private ready = false;
-  private embedCallCount = 0;
 
   constructor(private readonly config: EmbeddingConfig) {}
 
@@ -40,7 +39,6 @@ export class EmbeddingService {
 
   async embed(text: string): Promise<number[]> {
     if (!this.ready || !this.ctx) throw new Error("Embeddings not initialized");
-    this.embedCallCount++;
     const result = await this.ctx.getEmbeddingFor(text);
     return Array.from(result.vector);
   }
@@ -58,16 +56,6 @@ export class EmbeddingService {
     return this.ready;
   }
 
-  drainEmbedCallCount(): number {
-    const count = this.embedCallCount;
-    this.embedCallCount = 0;
-    return count;
-  }
-
-  getEmbedCallCount(): number {
-    return this.embedCallCount;
-  }
-
   async dispose(): Promise<void> {
     try {
       await this.ctx?.dispose();

package/src/graph-context.ts

@@ -634,9 +634,9 @@ async function formatContextMessage(
 
 function truncateToolResult(msg: AgentMessage, maxChars: number): AgentMessage {
   if (!isToolResult(msg)) return msg;
-  const totalLen = msg.content.reduce((s, c) => s + ((c as TextContent).text?.length ?? 0), 0);
+  const totalLen = msg.content.reduce((s: number, c: any) => s + ((c as TextContent).text?.length ?? 0), 0);
   if (totalLen <= maxChars) return msg;
-  const content = msg.content.map((c) => {
+  const content = msg.content.map((c: any) => {
     if (c.type !== "text") return c;
     const tc = c as TextContent;
     const allowed = Math.max(200, Math.floor((tc.text.length / totalLen) * maxChars));
@@ -654,8 +654,8 @@ function getRecentTurns(messages: AgentMessage[], maxTokens: number, contextWind
   const clean = messages.map((m) => {
     if (isAssistant(m) && m.stopReason === "error") {
       const errorText = m.content
-        .filter((c): c is TextContent => c.type === "text")
-        .map((c) => c.text)
+        .filter((c: any): c is TextContent => c.type === "text")
+        .map((c: any) => c.text)
         .join("")
         .slice(0, 150);
       return {
@@ -672,7 +672,7 @@ function getRecentTurns(messages: AgentMessage[], maxTokens: number, contextWind
   let i = 0;
   while (i < clean.length) {
     const msg = clean[i];
-    if (isAssistant(msg) && msg.content.some((c) => c.type === "toolCall")) {
+    if (isAssistant(msg) && msg.content.some((c: any) => c.type === "toolCall")) {
       const group: AgentMessage[] = [clean[i]];
       let j = i + 1;
       while (j < clean.length && isToolResult(clean[j])) {
@@ -837,9 +837,19 @@ async function graphTransformInner(
   const config = session.currentConfig;
   const skipRetrieval = config?.skipRetrieval ?? false;
   const currentIntent = config?.intent ?? "unknown";
-  const vectorSearchLimits = config?.vectorSearchLimits ?? {
+  const baseLimits = config?.vectorSearchLimits ?? {
     turn: 25, identity: 10, concept: 20, memory: 20, artifact: 10,
   };
+  // Scale search limits with context window — larger windows can use more results
+  const cwScale = Math.max(0.5, Math.min(2.0, contextWindow / 200_000));
+  const vectorSearchLimits = {
+    turn: Math.round((baseLimits.turn ?? 25) * cwScale),
+    identity: baseLimits.identity,  // always load full identity
+    concept: Math.round((baseLimits.concept ?? 20) * cwScale),
+    memory: Math.round((baseLimits.memory ?? 20) * cwScale),
+    artifact: Math.round((baseLimits.artifact ?? 10) * cwScale),
+    monologue: Math.round(8 * cwScale),
+  };
   let tokenBudget = Math.min(config?.tokenBudget ?? 6000, budgets.retrieval);
 
   // Pressure-based adaptive scaling

package/src/hooks/llm-output.ts

@@ -30,9 +30,16 @@ export function createLlmOutputHandler(state: GlobalPluginState) {
     const session = state.getSession(sessionKey);
     if (!session) return;
 
-    // Extract token counts (0 if provider didn't report usage)
-    const inputTokens = event.usage?.input ?? 0;
-    const outputTokens = event.usage?.output ?? 0;
+    // Measure assistant text output (used for token estimation and planning gate)
+    const textLen = event.assistantTexts.reduce((s, t) => s + t.length, 0);
+
+    // Extract token counts — fall back to text-length estimate when provider
+    // doesn't report usage (OpenClaw often passes 0 or undefined)
+    let inputTokens = event.usage?.input ?? 0;
+    let outputTokens = event.usage?.output ?? 0;
+    if (inputTokens + outputTokens === 0 && textLen > 0) {
+      outputTokens = Math.ceil(textLen / 4); // ~4 chars per token
+    }
 
     // Always update session stats — turn_count must increment even without usage data
     if (session.surrealSessionId) {
@@ -47,13 +54,11 @@ export function createLlmOutputHandler(state: GlobalPluginState) {
       }
     }
 
-    // Accumulate for daemon batching (only when real tokens present)
-    if (inputTokens + outputTokens > 0) {
-      session.newContentTokens += inputTokens + outputTokens;
-    }
+    // Accumulate for daemon batching and mid-session cleanup
+    session.newContentTokens += inputTokens + outputTokens;
+    session.cumulativeTokens += inputTokens + outputTokens;
 
     // Track accumulated text output for planning gate
-    const textLen = event.assistantTexts.reduce((s, t) => s + t.length, 0);
     session.turnTextLength += textLen;
 
     if (textLen > 50) {
@@ -77,6 +82,11 @@ export function createLlmOutputHandler(state: GlobalPluginState) {
           const thinking = block.thinking ?? block.text ?? "";
           if (thinking.length > 50) {
             session.pendingThinking.push(thinking);
+            // Cap to prevent unbounded growth in long sessions
+            const max = state.config.thresholds.maxPendingThinking;
+            if (session.pendingThinking.length > max) {
+              session.pendingThinking.splice(0, session.pendingThinking.length - max);
+            }
           }
         }
       }

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,10 +459,11 @@ export default definePluginEntry({
       // Start memory daemon worker thread
       try {
         session.daemon = startMemoryDaemon(
-          config.surreal,
-          config.embedding,
+          globalState!.store,
+          globalState!.embeddings,
           session.sessionId,
           globalState!.complete,
+          globalState!.config.thresholds.extractionTimeoutMs,
         );
       } catch (e) {
         swallow.warn("index:startDaemon", e);
@@ -476,7 +477,7 @@ export default definePluginEntry({
               (session as any)._hasMigratableFiles = true;
             }
           })
-          .catch(e => swallow("index:migrationCheck", e));
+          .catch(e => swallow.warn("index:migrationCheck", e));
       }
 
       // Set reflection context window from config
@@ -486,20 +487,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

@@ -76,8 +76,6 @@ DEFINE FIELD IF NOT EXISTS model ON turn TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS usage ON turn TYPE option<object>;
 DEFINE INDEX IF NOT EXISTS turn_vec_idx ON turn FIELDS embedding HNSW DIMENSION 1024 DIST COSINE;
 DEFINE INDEX IF NOT EXISTS turn_session_idx ON turn FIELDS session_id;
--- Migration: backfill created_at from timestamp for existing turns
-UPDATE turn SET created_at = timestamp WHERE created_at IS NONE AND timestamp IS NOT NONE;
 
 -- Identity chunks (agent persona / identity)
 DEFINE TABLE IF NOT EXISTS identity_chunk SCHEMALESS;
@@ -112,7 +110,6 @@ DEFINE FIELD IF NOT EXISTS source ON memory TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS created_at ON memory TYPE datetime DEFAULT time::now();
 DEFINE FIELD IF NOT EXISTS last_accessed ON memory TYPE option<datetime>;
 DEFINE FIELD IF NOT EXISTS status ON memory TYPE option<string> DEFAULT "active";
-UPDATE memory SET status = "active" WHERE status IS NONE;
 DEFINE FIELD IF NOT EXISTS resolved_at ON memory TYPE option<datetime>;
 DEFINE FIELD IF NOT EXISTS resolved_by ON memory TYPE option<string>;
 DEFINE INDEX IF NOT EXISTS memory_vec_idx ON memory FIELDS embedding HNSW DIMENSION 1024 DIST COSINE;
@@ -375,15 +372,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)}`,
       }],
     });
 
@@ -163,7 +154,7 @@ export async function supersedeOldSkills(
         );
       }
     }
-  } catch (e) { swallow("skills:supersedeOld", e); }
+  } catch (e) { swallow.warn("skills:supersedeOld", e); }
 }
 
 // --- Skill Retrieval ---

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

@@ -54,9 +54,14 @@ export class SessionState {
   // Memory daemon
   daemon: MemoryDaemon | null = null;
   newContentTokens = 0;
-  readonly DAEMON_TOKEN_THRESHOLD = 4000;
+  daemonTokenThreshold = 4000;
   lastDaemonFlushTurnCount = 0;
 
+  // Cumulative session token tracking (for mid-session cleanup trigger)
+  cumulativeTokens = 0;
+  lastCleanupTokens = 0;
+  midSessionCleanupThreshold = 100_000;
+
   // Cleanup tracking
   cleanedUp = false;
 
@@ -101,6 +106,7 @@ export class GlobalPluginState {
   complete: CompleteFn;
   workspaceDir?: string;
   enqueueSystemEvent?: EnqueueSystemEventFn;
+  schemaApplied = false;
   private sessions = new Map<string, SessionState>();
 
   constructor(
@@ -120,6 +126,8 @@ export class GlobalPluginState {
     let session = this.sessions.get(sessionKey);
     if (!session) {
       session = new SessionState(sessionId, sessionKey);
+      session.daemonTokenThreshold = this.config.thresholds.daemonTokenThreshold;
+      session.midSessionCleanupThreshold = this.config.thresholds.midSessionCleanupThreshold;
       this.sessions.set(sessionKey, session);
     }
     return session;

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 },
       );
@@ -1061,16 +1062,16 @@ export class SurrealStore {
 
   async runMemoryMaintenance(): Promise<void> {
     try {
-      await this.queryExec(
-        `UPDATE memory SET importance = math::max([importance * 0.95, 2.0]) WHERE importance > 2.0`,
-      );
-      await this.queryExec(
-        `UPDATE memory SET importance = math::max([importance, 3 + ((
+      // Single round-trip to reduce transaction conflict window
+      await this.queryExec(`
+        UPDATE memory SET importance = math::max([importance * 0.95, 2.0]) WHERE importance > 2.0;
+        UPDATE memory SET importance = math::max([importance, 3 + ((
           SELECT VALUE avg_utilization FROM memory_utility_cache WHERE memory_id = string::concat(meta::tb(id), ":", meta::id(id)) LIMIT 1
-        )[0] ?? 0) * 4]) WHERE importance < 7`,
-      );
+        )[0] ?? 0) * 4]) WHERE importance < 7;
+      `);
     } catch (e) {
-      swallow.warn("surreal:runMemoryMaintenance", e);
+      // Transaction conflicts expected when daemon writes concurrently — silent
+      swallow("surreal:runMemoryMaintenance", e);
     }
   }
 

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 };
           }