kongbrain 0.2.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.2.1",
+  "version": "0.3.2",
   "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

@@ -94,7 +94,12 @@ function loadWeights(path: string): ACANWeights | null {
     if (!Array.isArray(raw.W_k) || raw.W_k.length !== EMBED_DIM) return null;
     if (!Array.isArray(raw.W_final) || raw.W_final.length !== FEATURE_COUNT) return null;
     if (typeof raw.bias !== "number") return null;
-    if (raw.W_q[0].length !== ATTN_DIM || raw.W_k[0].length !== ATTN_DIM) return null;
+    // Validate inner dimensions — check first, middle, and last rows to catch crafted files
+    const checkIndices = [0, Math.floor(EMBED_DIM / 2), EMBED_DIM - 1];
+    for (const i of checkIndices) {
+      if (!Array.isArray(raw.W_q[i]) || raw.W_q[i].length !== ATTN_DIM) return null;
+      if (!Array.isArray(raw.W_k[i]) || raw.W_k[i].length !== ATTN_DIM) return null;
+    }
     return raw as ACANWeights;
   } catch (e) {
     swallow("acan:loadWeights", e);
@@ -282,8 +287,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 +301,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/causal.ts

@@ -138,8 +138,8 @@ export async function queryCausalContext(
         store.queryFirst<any>(
           `SELECT id, text, importance, access_count AS accessCount,
                   created_at AS timestamp, category, meta::tb(id) AS table${scoreExpr}
-           FROM ${id}->${edge}->? LIMIT 3`,
-          bindings,
+           FROM type::record($nid)->${edge}->? LIMIT 3`,
+          { ...bindings, nid: id },
         ).catch(e => { swallow.warn("causal:edge-query", e); return [] as any[]; }),
       ),
     );
@@ -149,8 +149,8 @@ export async function queryCausalContext(
         store.queryFirst<any>(
           `SELECT id, text, importance, access_count AS accessCount,
                   created_at AS timestamp, category, meta::tb(id) AS table${scoreExpr}
-           FROM ${id}<-${edge}<-? LIMIT 3`,
-          bindings,
+           FROM type::record($nid)<-${edge}<-? LIMIT 3`,
+          { ...bindings, nid: id },
         ).catch(e => { swallow.warn("causal:edge-query", e); return [] as any[]; }),
       ),
     );

package/src/cognitive-check.ts

@@ -183,12 +183,14 @@ Return ONLY valid JSON.`,
       if (g.learned) {
         // Agent followed the correction unprompted — decay toward background (floor 3)
         await store.queryExec(
-          `UPDATE ${g.id} SET importance = math::max([3, importance - 2])`,
+          `UPDATE type::record($gid) SET importance = math::max([3, importance - 2])`,
+          { gid: g.id },
         ).catch(e => swallow.warn("cognitive-check:correctionDecay", e));
       } else {
         // Correction was relevant but agent ignored it — reinforce (cap 9)
         await store.queryExec(
-          `UPDATE ${g.id} SET importance = math::min([9, importance + 1])`,
+          `UPDATE type::record($gid) SET importance = math::min([9, importance + 1])`,
+          { gid: g.id },
         ).catch(e => swallow.warn("cognitive-check:correctionReinforce", e));
       }
     }
@@ -218,8 +220,8 @@ Return ONLY valid JSON.`,
     const resolvedGrades = result.grades.filter(g => g.resolved && g.id.startsWith("memory:"));
     for (const g of resolvedGrades) {
       await store.queryExec(
-        `UPDATE ${g.id} SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
-        { sid: params.sessionId },
+        `UPDATE type::record($gid) SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
+        { gid: g.id, sid: params.sessionId },
       ).catch(e => swallow.warn("cognitive-check:resolve", e));
     }
   } catch (e) {
@@ -234,7 +236,7 @@ Return ONLY valid JSON.`,
 export function parseCheckResponse(text: string): CognitiveCheckResult | null {
   // Strip markdown fences if present
   const stripped = text.replace(/```(?:json)?\s*/g, "").replace(/```\s*$/g, "");
-  const jsonMatch = stripped.match(/\{[\s\S]*\}/);
+  const jsonMatch = stripped.match(/\{[\s\S]*?\}/);
   if (!jsonMatch) return null;
 
   let raw: any;
@@ -316,8 +318,8 @@ async function applyRetrievalGrades(
       );
       if (row?.[0]?.id) {
         await store.queryExec(
-          `UPDATE ${row[0].id} SET llm_relevance = $score, llm_relevant = $relevant, llm_reason = $reason`,
-          { score: grade.score, relevant: grade.relevant, reason: grade.reason },
+          `UPDATE type::record($rid) SET llm_relevance = $score, llm_relevant = $relevant, llm_reason = $reason`,
+          { rid: String(row[0].id), score: grade.score, relevant: grade.relevant, reason: grade.reason },
         );
       }
       // Feed relevance score into the utility cache — drives WMR provenUtility scoring

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 : 25_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

@@ -73,19 +73,22 @@ 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
@@ -122,6 +125,7 @@ export class KongBrainContextEngine implements ContextEngine {
         if (!session.daemon) {
           session.daemon = startMemoryDaemon(
             store, embeddings, session.sessionId, this.state.complete,
+            this.state.config.thresholds.extractionTimeoutMs,
           );
         }
       } catch (e) {
@@ -135,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));
 
@@ -404,7 +408,7 @@ export class KongBrainContextEngine implements ContextEngine {
     }
 
     // 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 {
@@ -439,7 +443,7 @@ export class KongBrainContextEngine implements ContextEngine {
     // 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") {
+    if (tokensSinceCleanup >= session.midSessionCleanupThreshold && typeof this.state.complete === "function") {
       session.lastCleanupTokens = session.cumulativeTokens;
 
       // Fire-and-forget: these are non-critical background operations
@@ -478,6 +482,12 @@ export class KongBrainContextEngine implements ContextEngine {
           .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 () => {

package/src/daemon-manager.ts

@@ -36,6 +36,7 @@ export function startMemoryDaemon(
   sharedEmbeddings: EmbeddingService,
   sessionId: string,
   complete: CompleteFn,
+  extractionTimeoutMs = 60_000,
 ): MemoryDaemon {
   // Use shared store/embeddings from global state (no duplicate connections)
   const store = sharedStore;
@@ -96,7 +97,7 @@ export function startMemoryDaemon(
 
     const responseText = response.text;
 
-    const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+    const jsonMatch = responseText.match(/\{[\s\S]*?\}/);
     if (!jsonMatch) return;
 
     let result: Record<string, any>;
@@ -137,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);

package/src/deferred-cleanup.ts

@@ -106,10 +106,16 @@ async function processOrphanedSession(
 
   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 LLM_CALL_TIMEOUT_MS = 30_000;
+    const response = await Promise.race([
+      complete({
+        system: systemPrompt,
+        messages: [{ role: "user", content: `[TRANSCRIPT]\n${transcript.slice(0, 60000)}` }],
+      }),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("LLM extraction call timed out")), LLM_CALL_TIMEOUT_MS),
+      ),
+    ]);
 
     const responseText = response.text;
     console.warn(`[deferred] extraction response: ${responseText.length} chars`);
@@ -144,10 +150,15 @@ async function processOrphanedSession(
       .map(t => `[${t.role}] ${t.text.slice(0, 200)}`)
       .join("\n");
 
-    const handoffResponse = await 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 handoffResponse = await Promise.race([
+      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 }],
+      }),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("LLM handoff call timed out")), 30_000),
+      ),
+    ]);
 
     const handoffText = handoffResponse.text.trim();
     console.warn(`[deferred] handoff response: ${handoffText.length} chars`);

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,14 +54,11 @@ 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;
-    }
+    // 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) {
@@ -78,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

@@ -65,6 +65,36 @@ async function runSessionCleanup(
   state: GlobalPluginState,
 ): Promise<void> {
   const { store: s, embeddings: emb } = state;
+  const { complete } = state;
+
+  // 1. Handoff FIRST — highest value, must survive even if cleanup races out
+  try {
+    const recentTurns = await s.getSessionTurns(session.sessionId, 15)
+      .catch(() => [] as { role: string; text: string }[]);
+    if (recentTurns.length >= 2) {
+      const turnSummary = recentTurns
+        .map(t => `[${t.role}] ${t.text.slice(0, 200)}`)
+        .join("\n");
+
+      const handoffResponse = await 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 (emb.isAvailable()) {
+          try { embedding = await emb.embed(handoffText); } catch { /* ok */ }
+        }
+        await s.createMemory(handoffText, embedding, 8, "handoff", session.sessionId);
+      }
+    }
+  } catch (e) {
+    swallow.warn("cleanup:handoff", e);
+  }
+
+  // 2. Everything else in parallel — lower priority, OK if timeout kills it
   const endOps: Promise<unknown>[] = [];
 
   // Final daemon flush — send full session for extraction
@@ -80,14 +110,12 @@ async function runSessionCleanup(
           }));
           session.daemon!.sendTurnBatch(turnData, [...session.pendingThinking], []);
         } catch (e) { swallow.warn("cleanup:finalDaemonFlush", e); }
-        await session.daemon!.shutdown(45_000).catch(e => swallow.warn("cleanup:daemonShutdown", e));
+        await session.daemon!.shutdown(10_000).catch(e => swallow.warn("cleanup:daemonShutdown", e));
         session.daemon = null;
       })(),
     );
   }
 
-  const { complete } = state;
-
   // Skill extraction
   if (session.taskId) {
     endOps.push(
@@ -113,10 +141,9 @@ async function runSessionCleanup(
     .catch(e => { swallow.warn("cleanup:soulGraduation", e); return null; });
   endOps.push(graduationPromise);
 
-  // The session-end LLM call is critical and needs the full 45s.
   await Promise.race([
     Promise.allSettled(endOps),
-    new Promise(resolve => setTimeout(resolve, 45_000)),
+    new Promise(resolve => setTimeout(resolve, 150_000)),
   ]);
 
   // If soul graduation just happened, persist a graduation event so the next
@@ -192,33 +219,6 @@ async function runSessionCleanup(
   } catch (e) {
     swallow.warn("cleanup:stageTransition", e);
   }
-
-  // Generate handoff note for next session wakeup
-  try {
-    const recentTurns = await s.getSessionTurns(session.sessionId, 15)
-      .catch(() => [] as { role: string; text: string }[]);
-    if (recentTurns.length >= 2) {
-      const turnSummary = recentTurns
-        .map(t => `[${t.role}] ${t.text.slice(0, 200)}`)
-        .join("\n");
-
-      const handoffResponse = await 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 (emb.isAvailable()) {
-          try { embedding = await emb.embed(handoffText); } catch { /* ok */ }
-        }
-        await s.createMemory(handoffText, embedding, 8, "handoff", session.sessionId);
-      }
-    }
-  } catch (e) {
-    swallow.warn("cleanup:handoff", e);
-  }
 }
 
 /**
@@ -463,6 +463,7 @@ export default definePluginEntry({
           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

package/src/memory-daemon.ts

@@ -174,8 +174,8 @@ export async function writeExtractionResults(
         if (typeof memId !== "string" || !RECORD_ID_RE.test(memId)) continue;
         counts.resolved++;
         await store.queryExec(
-          `UPDATE ${memId} SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
-          { sid: sessionId },
+          `UPDATE type::record($mid) SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
+          { mid: memId, sid: sessionId },
         ).catch(e => swallow.warn("daemon:resolveMemory", e));
       }
     })());

package/src/prefetch.ts

@@ -46,9 +46,11 @@ export function getPrefetchHitRate(): { hits: number; misses: number; attempts:
 
 function evictStale(): void {
   const now = Date.now();
+  const staleKeys: string[] = [];
   for (const [key, entry] of warmCache) {
-    if (now - entry.timestamp > CACHE_TTL_MS) warmCache.delete(key);
+    if (now - entry.timestamp > CACHE_TTL_MS) staleKeys.push(key);
   }
+  for (const key of staleKeys) warmCache.delete(key);
   while (warmCache.size > MAX_CACHE_SIZE) {
     const oldest = warmCache.keys().next().value;
     if (oldest) warmCache.delete(oldest);

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;

package/src/skills.ts

@@ -80,7 +80,7 @@ export async function extractSkill(
 
     if (text.trim() === "null" || text.trim() === "None") return null;
 
-    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    const jsonMatch = text.match(/\{[\s\S]*?\}/);
     if (!jsonMatch) return null;
 
     const parsed = JSON.parse(jsonMatch[0]) as ExtractedSkill;
@@ -154,7 +154,7 @@ export async function supersedeOldSkills(
         );
       }
     }
-  } catch (e) { swallow("skills:supersedeOld", e); }
+  } catch (e) { swallow.warn("skills:supersedeOld", e); }
 }
 
 // --- Skill Retrieval ---
@@ -238,11 +238,11 @@ export async function recordSkillOutcome(
   try {
     const field = success ? "success_count" : "failure_count";
     await store.queryExec(
-      `UPDATE ${skillId} SET
+      `UPDATE type::record($sid) SET
         ${field} += 1,
         avg_duration_ms = (avg_duration_ms * (success_count + failure_count - 1) + $dur) / (success_count + failure_count),
         last_used = time::now()`,
-      { dur: durationMs },
+      { sid: skillId, dur: durationMs },
     );
   } catch (e) { swallow("skills:non-critical", e); }
 }
@@ -289,7 +289,7 @@ export async function graduateCausalToSkills(
       });
 
       const text = resp.text;
-      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      const jsonMatch = text.match(/\{[\s\S]*?\}/);
       if (!jsonMatch) continue;
 
       let parsed: ExtractedSkill;

package/src/soul.ts

@@ -457,6 +457,8 @@ export async function reviseSoul(
   store: SurrealStore,
 ): Promise<boolean> {
   if (!store.isAvailable()) return false;
+  const ALLOWED_SECTIONS = new Set(["working_style", "emotional_dimensions", "self_observations", "earned_values"]);
+  if (!ALLOWED_SECTIONS.has(section)) return false;
   try {
     const now = new Date().toISOString();
     await store.queryExec(
@@ -567,7 +569,7 @@ Be honest, not aspirational. Only claim what the data supports.`;
     });
 
     const text = response.text.trim();
-    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    const jsonMatch = text.match(/\{[\s\S]*?\}/);
     if (!jsonMatch) return null;
 
     const parsed = JSON.parse(jsonMatch[0]);
@@ -842,7 +844,7 @@ CURRENT QUALITY:
     });
 
     const text = response.text.trim();
-    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    const jsonMatch = text.match(/\{[\s\S]*?\}/);
     if (!jsonMatch) return false;
 
     const revisions = JSON.parse(jsonMatch[0]);

package/src/state.ts

@@ -54,13 +54,13 @@ 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;
-  readonly MID_SESSION_CLEANUP_THRESHOLD = 100_000;
+  midSessionCleanupThreshold = 25_000;
 
   // Cleanup tracking
   cleanedUp = false;
@@ -106,6 +106,7 @@ export class GlobalPluginState {
   complete: CompleteFn;
   workspaceDir?: string;
   enqueueSystemEvent?: EnqueueSystemEventFn;
+  schemaApplied = false;
   private sessions = new Map<string, SessionState>();
 
   constructor(
@@ -125,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

@@ -168,7 +168,7 @@ export class SurrealStore {
             await new Promise((r) => setTimeout(r, BACKOFF_MS[attempt - 1]));
           } else {
             console.error(`[ERROR] SurrealDB reconnection failed after ${MAX_ATTEMPTS} attempts.`);
-            throw e;
+            throw new Error("SurrealDB reconnection failed");
           }
         }
       }
@@ -447,7 +447,10 @@ export class SurrealStore {
     assertRecordId(fromId);
     assertRecordId(toId);
     const safeName = edge.replace(/[^a-zA-Z0-9_]/g, "");
-    await this.queryExec(`RELATE ${fromId}->${safeName}->${toId}`);
+    await this.queryExec(
+      `RELATE type::record($from)->${safeName}->type::record($to)`,
+      { from: fromId, to: toId },
+    );
   }
 
   // ── 5-Pillar entity operations ─────────────────────────────────────────
@@ -501,12 +504,12 @@ export class SurrealStore {
   ): Promise<void> {
     assertRecordId(sessionId);
     await this.queryExec(
-      `UPDATE ${sessionId} SET
+      `UPDATE type::record($sid) SET
         turn_count += 1,
         total_input_tokens += $input,
         total_output_tokens += $output,
         last_active = time::now()`,
-      { input: inputTokens, output: outputTokens },
+      { sid: sessionId, input: inputTokens, output: outputTokens },
     );
   }
 
@@ -514,25 +517,27 @@ export class SurrealStore {
     assertRecordId(sessionId);
     if (summary) {
       await this.queryExec(
-        `UPDATE ${sessionId} SET ended_at = time::now(), summary = $summary`,
-        { summary },
+        `UPDATE type::record($sid) SET ended_at = time::now(), summary = $summary`,
+        { sid: sessionId, summary },
       );
     } else {
-      await this.queryExec(`UPDATE ${sessionId} SET ended_at = time::now()`);
+      await this.queryExec(`UPDATE type::record($sid) SET ended_at = time::now()`, { sid: sessionId });
     }
   }
 
   async markSessionActive(sessionId: string): Promise<void> {
     assertRecordId(sessionId);
     await this.queryExec(
-      `UPDATE ${sessionId} SET cleanup_completed = false, last_active = time::now()`,
+      `UPDATE type::record($sid) SET cleanup_completed = false, last_active = time::now()`,
+      { sid: sessionId },
     );
   }
 
   async markSessionEnded(sessionId: string): Promise<void> {
     assertRecordId(sessionId);
     await this.queryExec(
-      `UPDATE ${sessionId} SET ended_at = time::now(), cleanup_completed = true`,
+      `UPDATE type::record($sid) SET ended_at = time::now(), cleanup_completed = true`,
+      { sid: sessionId },
     );
   }
 
@@ -547,19 +552,39 @@ export class SurrealStore {
   }
 
   async linkSessionToTask(sessionId: string, taskId: string): Promise<void> {
-    await this.queryExec(`RELATE ${sessionId}->session_task->${taskId}`);
+    assertRecordId(sessionId);
+    assertRecordId(taskId);
+    await this.queryExec(
+      `RELATE type::record($from)->session_task->type::record($to)`,
+      { from: sessionId, to: taskId },
+    );
   }
 
   async linkTaskToProject(taskId: string, projectId: string): Promise<void> {
-    await this.queryExec(`RELATE ${taskId}->task_part_of->${projectId}`);
+    assertRecordId(taskId);
+    assertRecordId(projectId);
+    await this.queryExec(
+      `RELATE type::record($from)->task_part_of->type::record($to)`,
+      { from: taskId, to: projectId },
+    );
   }
 
   async linkAgentToTask(agentId: string, taskId: string): Promise<void> {
-    await this.queryExec(`RELATE ${agentId}->performed->${taskId}`);
+    assertRecordId(agentId);
+    assertRecordId(taskId);
+    await this.queryExec(
+      `RELATE type::record($from)->performed->type::record($to)`,
+      { from: agentId, to: taskId },
+    );
   }
 
   async linkAgentToProject(agentId: string, projectId: string): Promise<void> {
-    await this.queryExec(`RELATE ${agentId}->owns->${projectId}`);
+    assertRecordId(agentId);
+    assertRecordId(projectId);
+    await this.queryExec(
+      `RELATE type::record($from)->owns->type::record($to)`,
+      { from: agentId, to: projectId },
+    );
   }
 
   // ── Graph traversal ────────────────────────────────────────────────────
@@ -600,7 +625,7 @@ export class SurrealStore {
     for (let hop = 0; hop < hops && frontier.length > 0; hop++) {
       const forwardQueries = frontier.flatMap((id) =>
         forwardEdges.map((edge) =>
-          this.queryFirst<any>(`${selectFields} FROM ${id}->${edge}->? LIMIT 3`, bindings).catch(
+          this.queryFirst<any>(`${selectFields} FROM type::record($nid)->${edge}->? LIMIT 3`, { ...bindings, nid: id }).catch(
             (e) => {
               swallow.warn("surreal:graphExpand", e);
               return [] as Record<string, unknown>[];
@@ -611,7 +636,7 @@ export class SurrealStore {
 
       const reverseQueries = frontier.flatMap((id) =>
         reverseEdges.map((edge) =>
-          this.queryFirst<any>(`${selectFields} FROM ${id}<-${edge}<-? LIMIT 3`, bindings).catch(
+          this.queryFirst<any>(`${selectFields} FROM type::record($nid)<-${edge}<-? LIMIT 3`, { ...bindings, nid: id }).catch(
             (e) => {
               swallow.warn("surreal:graphExpand", e);
               return [] as Record<string, unknown>[];
@@ -662,7 +687,8 @@ export class SurrealStore {
       try {
         assertRecordId(id);
         await this.queryExec(
-          `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`,
+          `UPDATE type::record($rid) SET access_count += 1, last_accessed = time::now()`,
+          { rid: id },
         );
       } catch (e) {
         swallow.warn("surreal:bumpAccessCounts", e);
@@ -683,7 +709,10 @@ export class SurrealStore {
     );
     if (rows.length > 0) {
       const id = String(rows[0].id);
-      await this.queryExec(`UPDATE ${id} SET access_count += 1, last_accessed = time::now()`);
+      await this.queryExec(
+        `UPDATE type::record($cid) SET access_count += 1, last_accessed = time::now()`,
+        { cid: id },
+      );
       return id;
     }
     const emb = embedding?.length ? embedding : undefined;
@@ -739,8 +768,8 @@ export class SurrealStore {
         const existing = dupes[0];
         const newImp = Math.max(existing.importance ?? 0, importance);
         await this.queryExec(
-          `UPDATE ${existing.id} SET access_count += 1, importance = $imp, last_accessed = time::now()`,
-          { imp: newImp },
+          `UPDATE type::record($eid) SET access_count += 1, importance = $imp, last_accessed = time::now()`,
+          { eid: String(existing.id), imp: newImp },
         );
         return String(existing.id);
       }
@@ -813,10 +842,11 @@ export class SurrealStore {
     fields: Partial<Pick<CoreMemoryEntry, "text" | "category" | "priority" | "tier" | "active">>,
   ): Promise<boolean> {
     assertRecordId(id);
+    const ALLOWED_FIELDS = new Set(["text", "category", "priority", "tier", "active"]);
     const sets: string[] = [];
-    const bindings: Record<string, unknown> = {};
+    const bindings: Record<string, unknown> = { _rid: id };
     for (const [key, val] of Object.entries(fields)) {
-      if (val !== undefined) {
+      if (val !== undefined && ALLOWED_FIELDS.has(key)) {
         sets.push(`${key} = $${key}`);
         bindings[key] = val;
       }
@@ -824,7 +854,7 @@ export class SurrealStore {
     if (sets.length === 0) return false;
     sets.push("updated_at = time::now()");
     const rows = await this.queryFirst<{ id: string }>(
-      `UPDATE ${id} SET ${sets.join(", ")} RETURN id`,
+      `UPDATE type::record($_rid) SET ${sets.join(", ")} RETURN id`,
       bindings,
     );
     return rows.length > 0;
@@ -832,7 +862,10 @@ export class SurrealStore {
 
   async deleteCoreMemory(id: string): Promise<void> {
     assertRecordId(id);
-    await this.queryExec(`UPDATE ${id} SET active = false, updated_at = time::now()`);
+    await this.queryExec(
+      `UPDATE type::record($rid) SET active = false, updated_at = time::now()`,
+      { rid: id },
+    );
   }
 
   async deactivateSessionMemories(sessionId: string): Promise<void> {
@@ -1062,16 +1095,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);
     }
   }
 
@@ -1190,10 +1223,10 @@ export class SurrealStore {
           assertRecordId(String(keep));
           assertRecordId(String(drop));
           await this.queryExec(
-            `UPDATE ${keep} SET access_count += 1, importance = math::max([importance, $imp])`,
-            { imp: dupe.importance },
+            `UPDATE type::record($kid) SET access_count += 1, importance = math::max([importance, $imp])`,
+            { kid: String(keep), imp: dupe.importance },
           );
-          await this.queryExec(`DELETE ${drop}`);
+          await this.queryExec(`DELETE type::record($did)`, { did: String(drop) });
           seen.add(String(drop));
           merged++;
         }
@@ -1218,7 +1251,10 @@ export class SurrealStore {
         try {
           const emb = await embedFn(mem.text);
           if (!emb) continue;
-          await this.queryExec(`UPDATE ${mem.id} SET embedding = $emb`, { emb });
+          await this.queryExec(
+            `UPDATE type::record($mid) SET embedding = $emb`,
+            { mid: String(mem.id), emb },
+          );
 
           const dupes = await this.queryFirst<{
             id: string;
@@ -1247,10 +1283,10 @@ export class SurrealStore {
             assertRecordId(String(keep));
             assertRecordId(String(drop));
             await this.queryExec(
-              `UPDATE ${keep} SET access_count += 1, importance = math::max([importance, $imp])`,
-              { imp: dupe.importance },
+              `UPDATE type::record($kid) SET access_count += 1, importance = math::max([importance, $imp])`,
+              { kid: String(keep), imp: dupe.importance },
             );
-            await this.queryExec(`DELETE ${drop}`);
+            await this.queryExec(`DELETE type::record($did)`, { did: String(drop) });
             seen.add(String(drop));
             merged++;
           }
@@ -1350,9 +1386,10 @@ export class SurrealStore {
     memoryId: string,
   ): Promise<void> {
     assertRecordId(checkpointId);
-    await this.queryExec(`UPDATE ${checkpointId} SET status = "complete", memory_id = $mid`, {
-      mid: memoryId,
-    });
+    await this.queryExec(
+      `UPDATE type::record($cpid) SET status = "complete", memory_id = $mid`,
+      { cpid: checkpointId, mid: memoryId },
+    );
   }
 
   async getPendingCheckpoints(

package/src/tools/introspect.ts

@@ -207,7 +207,7 @@ async function verifyAction(store: any, recordId?: string) {
     return { content: [{ type: "text" as const, text: `Error: invalid record ID "${recordId}".` }], details: null };
   }
 
-  const rows = await store.queryFirst(`SELECT * FROM ${recordId}`);
+  const rows = await store.queryFirst(`SELECT * FROM type::record($rid)`, { rid: recordId });
   if (rows.length === 0) {
     return { content: [{ type: "text" as const, text: `Record not found: ${recordId}` }], details: { exists: false } };
   }

package/src/wakeup.ts

@@ -297,7 +297,7 @@ Return ONLY valid JSON.`,
 
     const text = response.text;
 
-    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    const jsonMatch = text.match(/\{[\s\S]*?\}/);
     if (!jsonMatch) return null;
 
     let raw: any;

package/src/workspace-migrate.ts

@@ -22,7 +22,7 @@
  * copyFile+unlink instead of rename (cross-filesystem safe).
  */
 
-import { readFile, readdir, stat, copyFile, unlink, mkdir, writeFile, rmdir } from "node:fs/promises";
+import { readFile, readdir, stat, lstat, copyFile, unlink, mkdir, writeFile, rmdir } from "node:fs/promises";
 import { join, basename, extname, relative, dirname, sep } from "node:path";
 import type { SurrealStore } from "./surreal.js";
 import type { EmbeddingService } from "./embeddings.js";
@@ -376,10 +376,10 @@ async function tryReadFile(absPath: string, rootDir: string): Promise<WorkspaceF
   if (SKIP_FILES.has(name)) return null;
 
   let s;
-  try { s = await stat(absPath); }
+  try { s = await lstat(absPath); }
   catch { return null; }
 
-  if (!s.isFile()) return null;
+  if (s.isSymbolicLink() || !s.isFile()) return null;
   if (s.size === 0 || s.size > MAX_FILE_SIZE) return null;
 
   try {
@@ -524,7 +524,7 @@ function parseFrontmatter(content: string): { frontmatter: Record<string, unknow
     }
 
     // Try JSON metadata block if present
-    const jsonMatch = fmBlock.match(/metadata:\s*\n\s*(\{[\s\S]*\})/);
+    const jsonMatch = fmBlock.match(/metadata:\s*\n\s*(\{[\s\S]*?\})/);
     if (jsonMatch) {
       try {
         result.metadata = JSON.parse(jsonMatch[1]);