kongbrain 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kongbrain",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "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);

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

@@ -79,7 +79,7 @@ export function parsePluginConfig(raw?: Record<string, unknown>): KongBrainConfi
       daemonTokenThreshold:
         typeof thresholds.daemonTokenThreshold === "number" ? thresholds.daemonTokenThreshold : 4000,
       midSessionCleanupThreshold:
-        typeof thresholds.midSessionCleanupThreshold === "number" ? thresholds.midSessionCleanupThreshold : 100_000,
+        typeof thresholds.midSessionCleanupThreshold === "number" ? thresholds.midSessionCleanupThreshold : 25_000,
       extractionTimeoutMs:
         typeof thresholds.extractionTimeoutMs === "number" ? thresholds.extractionTimeoutMs : 60_000,
       maxPendingThinking:

package/src/daemon-manager.ts

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

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/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);
-  }
 }
 
 /**

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/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;
@@ -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

@@ -60,7 +60,7 @@ export class SessionState {
   // Cumulative session token tracking (for mid-session cleanup trigger)
   cumulativeTokens = 0;
   lastCleanupTokens = 0;
-  midSessionCleanupThreshold = 100_000;
+  midSessionCleanupThreshold = 25_000;
 
   // Cleanup tracking
   cleanedUp = false;

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> {
@@ -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]);