kongbrain 0.3.5 → 0.3.9

package/src/cognitive-check.ts

@@ -11,6 +11,7 @@
 import type { CompleteFn, SessionState } from "./state.js";
 import type { SurrealStore } from "./surreal.js";
 import { swallow } from "./errors.js";
+import { assertRecordId } from "./surreal.js";
 
 // --- Types ---
 
@@ -182,15 +183,17 @@ Return ONLY valid JSON.`,
     for (const g of correctionGrades) {
       if (g.learned) {
         // Agent followed the correction unprompted — decay toward background (floor 3)
+        assertRecordId(g.id);
+        // Direct interpolation safe: assertRecordId validates format above
         await store.queryExec(
-          `UPDATE type::record($gid) SET importance = math::max([3, importance - 2])`,
-          { gid: g.id },
+          `UPDATE ${g.id} SET importance = math::max([3, importance - 2])`,
         ).catch(e => swallow.warn("cognitive-check:correctionDecay", e));
       } else {
         // Correction was relevant but agent ignored it — reinforce (cap 9)
+        assertRecordId(g.id);
+        // Direct interpolation safe: assertRecordId validates format above
         await store.queryExec(
-          `UPDATE type::record($gid) SET importance = math::min([9, importance + 1])`,
-          { gid: g.id },
+          `UPDATE ${g.id} SET importance = math::min([9, importance + 1])`,
         ).catch(e => swallow.warn("cognitive-check:correctionReinforce", e));
       }
     }
@@ -219,9 +222,11 @@ Return ONLY valid JSON.`,
     // Mid-session resolution — mark addressed memories immediately
     const resolvedGrades = result.grades.filter(g => g.resolved && g.id.startsWith("memory:"));
     for (const g of resolvedGrades) {
+      assertRecordId(g.id);
+      // Direct interpolation safe: assertRecordId validates format above
       await store.queryExec(
-        `UPDATE type::record($gid) SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
-        { gid: g.id, sid: params.sessionId },
+        `UPDATE ${g.id} SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
+        { sid: params.sessionId },
       ).catch(e => swallow.warn("cognitive-check:resolve", e));
     }
   } catch (e) {
@@ -317,9 +322,12 @@ async function applyRetrievalGrades(
         { id: grade.id, sid: sessionId },
       );
       if (row?.[0]?.id) {
+        const rid = String(row[0].id);
+        assertRecordId(rid);
+        // Direct interpolation safe: assertRecordId validates format above
         await store.queryExec(
-          `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 },
+          `UPDATE ${rid} SET llm_relevance = $score, llm_relevant = $relevant, llm_reason = $reason`,
+          { score: grade.score, relevant: grade.relevant, reason: grade.reason },
         );
       }
       // Feed relevance score into the utility cache — drives WMR provenUtility scoring

package/src/concept-extract.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared concept-extraction helpers.
+ *
+ * Regex-based extraction of concept names from text, plus helpers to
+ * upsert extracted concepts and link them via arbitrary edge types.
+ */
+
+import type { SurrealStore } from "./surreal.js";
+import type { EmbeddingService } from "./embeddings.js";
+import { swallow } from "./errors.js";
+
+// Same regexes used by the original extractAndLinkConcepts in context-engine.
+export const CONCEPT_RE = /\b(?:(?:use|using|implement|create|add|configure|setup|install|import)\s+)([A-Z][a-zA-Z0-9_-]+(?:\s+[A-Z][a-zA-Z0-9_-]+)?)/g;
+export const TECH_TERMS = /\b(api|database|schema|migration|endpoint|middleware|component|service|module|handler|controller|model|interface|type|class|function|method|hook|plugin|extension|config|cache|queue|worker|daemon)\b/gi;
+
+/** Extract concept name strings from free text using regex heuristics. */
+export function extractConceptNames(text: string): string[] {
+  const concepts = new Set<string>();
+
+  let match: RegExpExecArray | null;
+  const re1 = new RegExp(CONCEPT_RE.source, CONCEPT_RE.flags);
+  while ((match = re1.exec(text)) !== null) {
+    concepts.add(match[1].trim());
+  }
+
+  const re2 = new RegExp(TECH_TERMS.source, TECH_TERMS.flags);
+  while ((match = re2.exec(text)) !== null) {
+    concepts.add(match[1].toLowerCase());
+  }
+
+  return [...concepts].slice(0, 10);
+}
+
+/**
+ * Upsert concepts from text and link them to a source node via the given edge.
+ *
+ * Used for:
+ *  - turn  → "mentions"          → concept  (existing behaviour)
+ *  - memory → "about_concept"    → concept  (Fix 1)
+ *  - artifact → "artifact_mentions" → concept (Fix 2)
+ */
+export async function upsertAndLinkConcepts(
+  sourceId: string,
+  edgeName: string,
+  text: string,
+  store: SurrealStore,
+  embeddings: EmbeddingService,
+  logTag: string,
+): Promise<void> {
+  const names = extractConceptNames(text);
+  if (names.length === 0) return;
+
+  for (const name of names) {
+    try {
+      let embedding: number[] | null = null;
+      if (embeddings.isAvailable()) {
+        try { embedding = await embeddings.embed(name); } catch { /* ok */ }
+      }
+      const conceptId = await store.upsertConcept(name, embedding);
+      if (conceptId) {
+        await store.relate(sourceId, edgeName, conceptId)
+          .catch(e => swallow(`${logTag}:relate`, e));
+      }
+    } catch (e) {
+      swallow(`${logTag}:upsert`, e);
+    }
+  }
+}
+
+/**
+ * Link a newly-upserted concept to existing concepts via narrower/broader
+ * edges when one concept's name is a substring of the other (indicating a
+ * parent-child hierarchy, e.g. "React" → "React hooks").
+ */
+export async function linkConceptHierarchy(
+  conceptId: string,
+  conceptName: string,
+  store: SurrealStore,
+  logTag: string,
+): Promise<void> {
+  try {
+    const existing = await store.queryFirst<{ id: string; content: string }>(
+      `SELECT id, content FROM concept WHERE id != $cid LIMIT 50`,
+      { cid: conceptId },
+    );
+    if (existing.length === 0) return;
+
+    const lowerName = conceptName.toLowerCase();
+
+    for (const other of existing) {
+      const otherLower = (other.content ?? "").toLowerCase();
+      if (!otherLower || otherLower === lowerName) continue;
+
+      const otherId = String(other.id);
+
+      if (lowerName.includes(otherLower) && lowerName !== otherLower) {
+        // New concept is more specific (e.g. "React hooks" contains "React")
+        await store.relate(conceptId, "narrower", otherId)
+          .catch(e => swallow(`${logTag}:narrower`, e));
+        await store.relate(otherId, "broader", conceptId)
+          .catch(e => swallow(`${logTag}:broader`, e));
+      } else if (otherLower.includes(lowerName) && otherLower !== lowerName) {
+        // New concept is more general (e.g. "React" contained in "React hooks")
+        await store.relate(conceptId, "broader", otherId)
+          .catch(e => swallow(`${logTag}:broader`, e));
+        await store.relate(otherId, "narrower", conceptId)
+          .catch(e => swallow(`${logTag}:narrower`, e));
+      }
+    }
+  } catch (e) {
+    swallow(`${logTag}:hierarchy`, e);
+  }
+}

package/src/context-engine.ts

@@ -51,6 +51,7 @@ import { extractSkill } from "./skills.js";
 import { generateReflection } from "./reflection.js";
 import { graduateCausalToSkills } from "./skills.js";
 import { swallow } from "./errors.js";
+import { upsertAndLinkConcepts } from "./concept-extract.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -305,6 +306,7 @@ export class KongBrainContextEngine implements ContextEngine {
           }
         } else {
           session.lastAssistantText = text;
+          if (turnId) session.lastAssistantTurnId = turnId;
         }
 
         return { ingested: true };
@@ -506,7 +508,11 @@ export class KongBrainContextEngine implements ContextEngine {
             if (embeddings.isAvailable()) {
               try { embedding = await embeddings.embed(handoffText); } catch { /* ok */ }
             }
-            await store.createMemory(handoffText, embedding, 8, "handoff", session.sessionId);
+            const handoffMemId = await store.createMemory(handoffText, embedding, 8, "handoff", session.sessionId);
+            if (handoffMemId && session.surrealSessionId) {
+              await store.relate(handoffMemId, "summarizes", session.surrealSessionId)
+                .catch(e => swallow.warn("midCleanup:summarizes", e));
+            }
           }
         })().catch(e => swallow.warn("midCleanup:handoff", e)),
       );
@@ -548,44 +554,15 @@ function hasSemantic(text: string): boolean {
   return text.split(/\s+/).filter(w => w.length > 2).length >= 3;
 }
 
-// --- Concept extraction (shared with llm-output hook) ---
-
-const CONCEPT_RE = /\b(?:(?:use|using|implement|create|add|configure|setup|install|import)\s+)([A-Z][a-zA-Z0-9_-]+(?:\s+[A-Z][a-zA-Z0-9_-]+)?)/g;
-const TECH_TERMS = /\b(api|database|schema|migration|endpoint|middleware|component|service|module|handler|controller|model|interface|type|class|function|method|hook|plugin|extension|config|cache|queue|worker|daemon)\b/gi;
+// --- Concept extraction (delegates to shared helper) ---
 
 async function extractAndLinkConcepts(
   turnId: string,
   text: string,
   state: GlobalPluginState,
 ): Promise<void> {
-  const concepts = new Set<string>();
-
-  let match: RegExpExecArray | null;
-  const re1 = new RegExp(CONCEPT_RE.source, CONCEPT_RE.flags);
-  while ((match = re1.exec(text)) !== null) {
-    concepts.add(match[1].trim());
-  }
-
-  const re2 = new RegExp(TECH_TERMS.source, TECH_TERMS.flags);
-  while ((match = re2.exec(text)) !== null) {
-    concepts.add(match[1].toLowerCase());
-  }
-
-  if (concepts.size === 0) return;
-
-  for (const conceptText of [...concepts].slice(0, 10)) {
-    try {
-      let embedding: number[] | null = null;
-      if (state.embeddings.isAvailable()) {
-        try { embedding = await state.embeddings.embed(conceptText); } catch { /* ok */ }
-      }
-      const conceptId = await state.store.upsertConcept(conceptText, embedding);
-      if (conceptId) {
-        await state.store.relate(turnId, "mentions", conceptId)
-          .catch(e => swallow("concepts:relate", e));
-      }
-    } catch (e) {
-      swallow("concepts:upsert", e);
-    }
-  }
+  await upsertAndLinkConcepts(
+    turnId, "mentions", text,
+    state.store, state.embeddings, "concepts",
+  );
 }

package/src/hooks/after-tool-call.ts

@@ -5,6 +5,7 @@
 import type { GlobalPluginState } from "../state.js";
 import { recordToolOutcome } from "../retrieval-quality.js";
 import { swallow } from "../errors.js";
+import { upsertAndLinkConcepts } from "../concept-extract.js";
 
 export function createAfterToolCallHandler(state: GlobalPluginState) {
   return async (
@@ -30,13 +31,20 @@ export function createAfterToolCallHandler(state: GlobalPluginState) {
       ? event.result.slice(0, 500)
       : JSON.stringify(event.result ?? "").slice(0, 500);
 
+    let toolResultTurnId: string | undefined;
     try {
-      await state.store.upsertTurn({
+      toolResultTurnId = await state.store.upsertTurn({
         session_id: session.sessionId,
         role: "tool",
         text: `[${event.toolName}] ${resultText}`,
         embedding: null,
       });
+
+      // Fix 5: Link tool result turn back to the assistant turn that triggered it
+      if (toolResultTurnId && session.lastAssistantTurnId) {
+        await state.store.relate(toolResultTurnId, "tool_result_of", session.lastAssistantTurnId)
+          .catch(e => swallow.warn("hook:afterToolCall:tool_result_of", e));
+      }
     } catch (e) {
       swallow("hook:afterToolCall:store", e);
     }
@@ -92,8 +100,15 @@ async function trackArtifact(
   const artifactId = await state.store.createArtifact(
     (args.path as string) ?? "shell", ext, description, emb,
   );
-  if (artifactId && taskId) {
-    await state.store.relate(taskId, "produced", artifactId)
-      .catch(e => swallow.warn("artifact:relate", e));
+  if (artifactId) {
+    if (taskId) {
+      await state.store.relate(taskId, "produced", artifactId)
+        .catch(e => swallow.warn("artifact:relate", e));
+    }
+    // Fix 2: Link artifact to concepts it mentions
+    await upsertAndLinkConcepts(
+      artifactId, "artifact_mentions", description,
+      state.store, state.embeddings, "artifact:concepts",
+    );
   }
 }

package/src/index.ts

@@ -23,6 +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 { seedCognitiveBootstrap } from "./cognitive-bootstrap.js";
 import { synthesizeWakeup } from "./wakeup.js";
 import { extractSkill } from "./skills.js";
 import { generateReflection, setReflectionContextWindow } from "./reflection.js";
@@ -418,6 +419,13 @@ export default definePluginEntry({
         .then(n => { if (n > 0) logger.info(`Seeded ${n} identity chunks`); })
         .catch(e => swallow.warn("factory:seedIdentity", e));
 
+      seedCognitiveBootstrap(store, embeddings)
+        .then(r => {
+          if (r.identitySeeded > 0 || r.coreSeeded > 0)
+            logger.info(`Cognitive bootstrap: ${r.identitySeeded} identity + ${r.coreSeeded} core`);
+        })
+        .catch(e => swallow.warn("factory:seedBootstrap", e));
+
       return new KongBrainContextEngine(state);
     });
 

package/src/memory-daemon.ts

@@ -12,6 +12,8 @@ import type { TurnData, PriorExtractions } from "./daemon-types.js";
 import type { SurrealStore } from "./surreal.js";
 import type { EmbeddingService } from "./embeddings.js";
 import { swallow } from "./errors.js";
+import { assertRecordId } from "./surreal.js";
+import { upsertAndLinkConcepts, linkConceptHierarchy } from "./concept-extract.js";
 
 // --- Build the extraction prompt ---
 
@@ -172,10 +174,12 @@ export async function writeExtractionResults(
     writeOps.push((async () => {
       for (const memId of result.resolved!.slice(0, 20)) {
         if (typeof memId !== "string" || !RECORD_ID_RE.test(memId)) continue;
+        assertRecordId(memId);
         counts.resolved++;
+        // Direct interpolation safe: assertRecordId validates format above
         await store.queryExec(
-          `UPDATE type::record($mid) SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
-          { mid: memId, sid: sessionId },
+          `UPDATE ${memId} SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
+          { sid: sessionId },
         ).catch(e => swallow.warn("daemon:resolveMemory", e));
       }
     })());
@@ -193,7 +197,10 @@ export async function writeExtractionResults(
         if (embeddings.isAvailable()) {
           try { emb = await embeddings.embed(c.content); } catch (e) { swallow("daemon:embedConcept", e); }
         }
-        await store.upsertConcept(c.content, emb, `daemon:${sessionId}`);
+        const conceptId = await store.upsertConcept(c.content, emb, `daemon:${sessionId}`);
+        if (conceptId) {
+          await linkConceptHierarchy(conceptId, c.name, store, "daemon:concept");
+        }
       })());
     }
   }
@@ -209,7 +216,10 @@ export async function writeExtractionResults(
         if (embeddings.isAvailable()) {
           try { emb = await embeddings.embed(text); } catch (e) { swallow("daemon:embedCorrection", e); }
         }
-        await store.createMemory(text, emb, 9, "correction", sessionId);
+        const memId = await store.createMemory(text, emb, 9, "correction", sessionId);
+        if (memId) {
+          await upsertAndLinkConcepts(memId, "about_concept", text, store, embeddings, "daemon:correction");
+        }
       })());
     }
   }
@@ -225,7 +235,10 @@ export async function writeExtractionResults(
         if (embeddings.isAvailable()) {
           try { emb = await embeddings.embed(text); } catch (e) { swallow("daemon:embedPreference", e); }
         }
-        await store.createMemory(text, emb, 7, "preference", sessionId);
+        const memId = await store.createMemory(text, emb, 7, "preference", sessionId);
+        if (memId) {
+          await upsertAndLinkConcepts(memId, "about_concept", text, store, embeddings, "daemon:preference");
+        }
       })());
     }
   }
@@ -243,7 +256,10 @@ export async function writeExtractionResults(
         if (embeddings.isAvailable()) {
           try { emb = await embeddings.embed(`${a.path} ${desc}`); } catch (e) { swallow("daemon:embedArtifact", e); }
         }
-        await store.createArtifact(a.path, a.action ?? "modified", desc, emb);
+        const artId = await store.createArtifact(a.path, a.action ?? "modified", desc, emb);
+        if (artId) {
+          await upsertAndLinkConcepts(artId, "artifact_mentions", `${a.path} ${desc}`, store, embeddings, "daemon:artifact");
+        }
       })());
     }
   }
@@ -259,7 +275,10 @@ export async function writeExtractionResults(
         if (embeddings.isAvailable()) {
           try { emb = await embeddings.embed(text); } catch (e) { swallow("daemon:embedDecision", e); }
         }
-        await store.createMemory(text, emb, 7, "decision", sessionId);
+        const memId = await store.createMemory(text, emb, 7, "decision", sessionId);
+        if (memId) {
+          await upsertAndLinkConcepts(memId, "about_concept", text, store, embeddings, "daemon:decision");
+        }
       })());
     }
   }

package/src/skills.ts

@@ -13,6 +13,7 @@ import type { CompleteFn } from "./state.js";
 import type { EmbeddingService } from "./embeddings.js";
 import type { SurrealStore } from "./surreal.js";
 import { swallow } from "./errors.js";
+import { assertRecordId } from "./surreal.js";
 
 // --- Types ---
 
@@ -237,12 +238,14 @@ export async function recordSkillOutcome(
 
   try {
     const field = success ? "success_count" : "failure_count";
+    assertRecordId(skillId);
+    // Direct interpolation safe: assertRecordId validates format above
     await store.queryExec(
-      `UPDATE type::record($sid) SET
+      `UPDATE ${skillId} SET
         ${field} += 1,
         avg_duration_ms = (avg_duration_ms * (success_count + failure_count - 1) + $dur) / (success_count + failure_count),
         last_used = time::now()`,
-      { sid: skillId, dur: durationMs },
+      { dur: durationMs },
     );
   } catch (e) { swallow("skills:non-critical", e); }
 }

package/src/state.ts

@@ -38,6 +38,7 @@ export class SessionState {
 
   // Turn tracking
   lastUserTurnId = "";
+  lastAssistantTurnId = "";
   lastUserText = "";
   lastAssistantText = "";
   toolCallCount = 0;

package/src/surreal.ts

@@ -447,10 +447,8 @@ export class SurrealStore {
     assertRecordId(fromId);
     assertRecordId(toId);
     const safeName = edge.replace(/[^a-zA-Z0-9_]/g, "");
-    await this.queryExec(
-      `RELATE type::record($from)->${safeName}->type::record($to)`,
-      { from: fromId, to: toId },
-    );
+    // Direct interpolation safe: assertRecordId validates format above
+    await this.queryExec(`RELATE ${fromId}->${safeName}->${toId}`);
   }
 
   // ── 5-Pillar entity operations ─────────────────────────────────────────
@@ -504,12 +502,12 @@ export class SurrealStore {
   ): Promise<void> {
     assertRecordId(sessionId);
     await this.queryExec(
-      `UPDATE type::record($sid) SET
+      `UPDATE ${sessionId} SET
         turn_count += 1,
         total_input_tokens += $input,
         total_output_tokens += $output,
         last_active = time::now()`,
-      { sid: sessionId, input: inputTokens, output: outputTokens },
+      { input: inputTokens, output: outputTokens },
     );
   }
 
@@ -517,27 +515,25 @@ export class SurrealStore {
     assertRecordId(sessionId);
     if (summary) {
       await this.queryExec(
-        `UPDATE type::record($sid) SET ended_at = time::now(), summary = $summary`,
-        { sid: sessionId, summary },
+        `UPDATE ${sessionId} SET ended_at = time::now(), summary = $summary`,
+        { summary },
       );
     } else {
-      await this.queryExec(`UPDATE type::record($sid) SET ended_at = time::now()`, { sid: sessionId });
+      await this.queryExec(`UPDATE ${sessionId} SET ended_at = time::now()`);
     }
   }
 
   async markSessionActive(sessionId: string): Promise<void> {
     assertRecordId(sessionId);
     await this.queryExec(
-      `UPDATE type::record($sid) SET cleanup_completed = false, last_active = time::now()`,
-      { sid: sessionId },
+      `UPDATE ${sessionId} SET cleanup_completed = false, last_active = time::now()`,
     );
   }
 
   async markSessionEnded(sessionId: string): Promise<void> {
     assertRecordId(sessionId);
     await this.queryExec(
-      `UPDATE type::record($sid) SET ended_at = time::now(), cleanup_completed = true`,
-      { sid: sessionId },
+      `UPDATE ${sessionId} SET ended_at = time::now(), cleanup_completed = true`,
     );
   }
 
@@ -555,8 +551,7 @@ export class SurrealStore {
     assertRecordId(sessionId);
     assertRecordId(taskId);
     await this.queryExec(
-      `RELATE type::record($from)->session_task->type::record($to)`,
-      { from: sessionId, to: taskId },
+      `RELATE ${sessionId}->session_task->${taskId}`,
     );
   }
 
@@ -564,8 +559,7 @@ export class SurrealStore {
     assertRecordId(taskId);
     assertRecordId(projectId);
     await this.queryExec(
-      `RELATE type::record($from)->task_part_of->type::record($to)`,
-      { from: taskId, to: projectId },
+      `RELATE ${taskId}->task_part_of->${projectId}`,
     );
   }
 
@@ -573,8 +567,7 @@ export class SurrealStore {
     assertRecordId(agentId);
     assertRecordId(taskId);
     await this.queryExec(
-      `RELATE type::record($from)->performed->type::record($to)`,
-      { from: agentId, to: taskId },
+      `RELATE ${agentId}->performed->${taskId}`,
     );
   }
 
@@ -582,8 +575,7 @@ export class SurrealStore {
     assertRecordId(agentId);
     assertRecordId(projectId);
     await this.queryExec(
-      `RELATE type::record($from)->owns->type::record($to)`,
-      { from: agentId, to: projectId },
+      `RELATE ${agentId}->owns->${projectId}`,
     );
   }
 
@@ -625,7 +617,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 type::record($nid)->${edge}->? LIMIT 3`, { ...bindings, nid: id }).catch(
+          this.queryFirst<any>(`${selectFields} FROM ${id}->${edge}->? LIMIT 3`, bindings).catch(
             (e) => {
               swallow.warn("surreal:graphExpand", e);
               return [] as Record<string, unknown>[];
@@ -636,7 +628,7 @@ export class SurrealStore {
 
       const reverseQueries = frontier.flatMap((id) =>
         reverseEdges.map((edge) =>
-          this.queryFirst<any>(`${selectFields} FROM type::record($nid)<-${edge}<-? LIMIT 3`, { ...bindings, nid: id }).catch(
+          this.queryFirst<any>(`${selectFields} FROM ${id}<-${edge}<-? LIMIT 3`, bindings).catch(
             (e) => {
               swallow.warn("surreal:graphExpand", e);
               return [] as Record<string, unknown>[];
@@ -687,8 +679,7 @@ export class SurrealStore {
       try {
         assertRecordId(id);
         await this.queryExec(
-          `UPDATE type::record($rid) SET access_count += 1, last_accessed = time::now()`,
-          { rid: id },
+          `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`,
         );
       } catch (e) {
         swallow.warn("surreal:bumpAccessCounts", e);
@@ -710,8 +701,7 @@ export class SurrealStore {
     if (rows.length > 0) {
       const id = String(rows[0].id);
       await this.queryExec(
-        `UPDATE type::record($cid) SET access_count += 1, last_accessed = time::now()`,
-        { cid: id },
+        `UPDATE ${id} SET access_count += 1, last_accessed = time::now()`,
       );
       return id;
     }
@@ -768,8 +758,8 @@ export class SurrealStore {
         const existing = dupes[0];
         const newImp = Math.max(existing.importance ?? 0, importance);
         await this.queryExec(
-          `UPDATE type::record($eid) SET access_count += 1, importance = $imp, last_accessed = time::now()`,
-          { eid: String(existing.id), imp: newImp },
+          `UPDATE ${String(existing.id)} SET access_count += 1, importance = $imp, last_accessed = time::now()`,
+          { imp: newImp },
         );
         return String(existing.id);
       }
@@ -844,7 +834,7 @@ export class SurrealStore {
     assertRecordId(id);
     const ALLOWED_FIELDS = new Set(["text", "category", "priority", "tier", "active"]);
     const sets: string[] = [];
-    const bindings: Record<string, unknown> = { _rid: id };
+    const bindings: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(fields)) {
       if (val !== undefined && ALLOWED_FIELDS.has(key)) {
         sets.push(`${key} = $${key}`);
@@ -854,7 +844,7 @@ export class SurrealStore {
     if (sets.length === 0) return false;
     sets.push("updated_at = time::now()");
     const rows = await this.queryFirst<{ id: string }>(
-      `UPDATE type::record($_rid) SET ${sets.join(", ")} RETURN id`,
+      `UPDATE ${id} SET ${sets.join(", ")} RETURN id`,
       bindings,
     );
     return rows.length > 0;
@@ -863,8 +853,7 @@ export class SurrealStore {
   async deleteCoreMemory(id: string): Promise<void> {
     assertRecordId(id);
     await this.queryExec(
-      `UPDATE type::record($rid) SET active = false, updated_at = time::now()`,
-      { rid: id },
+      `UPDATE ${id} SET active = false, updated_at = time::now()`,
     );
   }
 
@@ -1013,9 +1002,9 @@ export class SurrealStore {
 
   async resolveMemory(memoryId: string): Promise<boolean> {
     try {
+      assertRecordId(memoryId);
       await this.queryFirst(
-        `UPDATE type::record($id) SET status = 'resolved', resolved_at = time::now()`,
-        { id: memoryId },
+        `UPDATE ${memoryId} SET status = 'resolved', resolved_at = time::now()`,
       );
       return true;
     } catch (e) {
@@ -1223,10 +1212,10 @@ export class SurrealStore {
           assertRecordId(String(keep));
           assertRecordId(String(drop));
           await this.queryExec(
-            `UPDATE type::record($kid) SET access_count += 1, importance = math::max([importance, $imp])`,
-            { kid: String(keep), imp: dupe.importance },
+            `UPDATE ${String(keep)} SET access_count += 1, importance = math::max([importance, $imp])`,
+            { imp: dupe.importance },
           );
-          await this.queryExec(`DELETE type::record($did)`, { did: String(drop) });
+          await this.queryExec(`DELETE ${String(drop)}`);
           seen.add(String(drop));
           merged++;
         }
@@ -1252,8 +1241,8 @@ export class SurrealStore {
           const emb = await embedFn(mem.text);
           if (!emb) continue;
           await this.queryExec(
-            `UPDATE type::record($mid) SET embedding = $emb`,
-            { mid: String(mem.id), emb },
+            `UPDATE ${String(mem.id)} SET embedding = $emb`,
+            { emb },
           );
 
           const dupes = await this.queryFirst<{
@@ -1283,10 +1272,10 @@ export class SurrealStore {
             assertRecordId(String(keep));
             assertRecordId(String(drop));
             await this.queryExec(
-              `UPDATE type::record($kid) SET access_count += 1, importance = math::max([importance, $imp])`,
-              { kid: String(keep), imp: dupe.importance },
+              `UPDATE ${String(keep)} SET access_count += 1, importance = math::max([importance, $imp])`,
+              { imp: dupe.importance },
             );
-            await this.queryExec(`DELETE type::record($did)`, { did: String(drop) });
+            await this.queryExec(`DELETE ${String(drop)}`);
             seen.add(String(drop));
             merged++;
           }
@@ -1387,8 +1376,8 @@ export class SurrealStore {
   ): Promise<void> {
     assertRecordId(checkpointId);
     await this.queryExec(
-      `UPDATE type::record($cpid) SET status = "complete", memory_id = $mid`,
-      { cpid: checkpointId, mid: memoryId },
+      `UPDATE ${checkpointId} SET status = "complete", memory_id = $mid`,
+      { mid: memoryId },
     );
   }