kongbrain 0.5.1 → 0.5.2

package/.clawhubignore

@@ -12,7 +12,6 @@ vitest.config.ts
 
 # Build/deps
 node_modules/
-dist/
 package-lock.json
 
 # Secrets/runtime

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: kongbrain
 description: Graph-backed persistent memory engine for OpenClaw. Replaces the default context window with SurrealDB + vector embeddings that learn across sessions.
-version: 0.5.1
+version: 0.5.2
 homepage: https://github.com/42U/kongbrain
 metadata:
   openclaw:
@@ -14,6 +14,11 @@ metadata:
         - SURREAL_PASS
         - SURREAL_NS
         - SURREAL_DB
+      optionalEnv:
+        - KONGBRAIN_EMBED_PROVIDER
+        - EMBED_MODEL_PATH
+        - OPENAI_BASE_URL
+        - OPENAI_API_KEY
     primaryEnv: SURREAL_URL
     install:
       - kind: node

package/dist/causal-CZ62YZ2J.js

@@ -0,0 +1,11 @@
+import {
+  getSessionCausalChains,
+  linkCausalEdges,
+  queryCausalContext
+} from "./chunk-6NWMZY3J.js";
+import "./chunk-XSIONAGJ.js";
+export {
+  getSessionCausalChains,
+  linkCausalEdges,
+  queryCausalContext
+};

package/dist/chunk-6NWMZY3J.js

@@ -0,0 +1,194 @@
+import {
+  assertRecordId,
+  init_errors,
+  swallow
+} from "./chunk-XSIONAGJ.js";
+
+// src/causal.ts
+init_errors();
+async function linkCausalEdges(chains, sessionId, store, embeddings) {
+  if (chains.length === 0 || !store.isAvailable()) return;
+  for (const chain of chains) {
+    try {
+      let triggerEmb = null;
+      if (embeddings.isAvailable()) {
+        try {
+          triggerEmb = await embeddings.embed(chain.triggerText);
+        } catch (e) {
+          swallow("causal:ok", e);
+        }
+      }
+      const triggerId = await store.createMemory(
+        chain.triggerText,
+        triggerEmb,
+        5,
+        `causal_trigger_${chain.chainType}`,
+        sessionId
+      );
+      let outcomeEmb = null;
+      if (embeddings.isAvailable()) {
+        try {
+          outcomeEmb = await embeddings.embed(chain.outcomeText);
+        } catch (e) {
+          swallow("causal:ok", e);
+        }
+      }
+      const outcomeId = await store.createMemory(
+        chain.outcomeText,
+        outcomeEmb,
+        6,
+        `causal_outcome_${chain.chainType}`,
+        sessionId
+      );
+      if (!triggerId || !outcomeId) continue;
+      await store.relate(outcomeId, "caused_by", triggerId).catch((e) => swallow.warn("causal:relateCausedBy", e));
+      if (chain.success) {
+        await store.relate(outcomeId, "supports", triggerId).catch((e) => swallow.warn("causal:relateSupports", e));
+      } else {
+        await store.relate(outcomeId, "contradicts", triggerId).catch((e) => swallow.warn("causal:relateContradicts", e));
+      }
+      let descriptionId = null;
+      if (chain.description && chain.description.length > 10) {
+        const descText = `[${chain.chainType}${chain.success ? "" : " FAILED"}] ${chain.description}`;
+        let descEmb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            descEmb = await embeddings.embed(descText);
+          } catch (e) {
+            swallow("causal:ok", e);
+          }
+        }
+        descriptionId = await store.createMemory(
+          descText,
+          descEmb,
+          5,
+          `causal_description_${chain.chainType}`,
+          sessionId
+        );
+        if (descriptionId) {
+          await store.relate(descriptionId, "describes", triggerId).catch((e) => swallow.warn("causal:relateDescTrigger", e));
+          await store.relate(descriptionId, "describes", outcomeId).catch((e) => swallow.warn("causal:relateDescOutcome", e));
+        }
+      }
+      await store.queryExec(`CREATE causal_chain CONTENT $data`, {
+        data: {
+          session_id: String(sessionId),
+          trigger_memory: triggerId,
+          outcome_memory: outcomeId,
+          description_memory: descriptionId,
+          chain_type: chain.chainType,
+          success: chain.success,
+          confidence: chain.confidence,
+          description: chain.description
+        }
+      }).catch((e) => swallow.warn("causal:storeChain", e));
+    } catch (e) {
+      swallow("causal:silent", e);
+    }
+  }
+}
+async function queryCausalContext(seedIds, queryVec, hops = 2, minConfidence = 0.4, store) {
+  if (seedIds.length === 0 || !store?.isAvailable()) return [];
+  const RECORD_ID_RE = /^[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z0-9_]+$/;
+  const validIds = seedIds.filter((id) => RECORD_ID_RE.test(id)).slice(0, 10);
+  if (validIds.length === 0) return [];
+  const causalEdges = ["caused_by", "supports", "contradicts", "describes"];
+  const seen = new Set(validIds);
+  let frontier = validIds;
+  const results = [];
+  const bindings = { vec: queryVec, provider: store.getActiveProvider() };
+  const scoreExpr = `, IF embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+         THEN vector::similarity::cosine(embedding, $vec)
+         ELSE 0 END AS score`;
+  for (let hop = 0; hop < hops && frontier.length > 0; hop++) {
+    const selectFields = `SELECT id, text, importance, access_count AS accessCount,
+                  created_at AS timestamp, category, meta::tb(id) AS table${scoreExpr}`;
+    const stmts = [];
+    for (const id of frontier) {
+      assertRecordId(id);
+      for (const edge of causalEdges) {
+        if (!/^[a-z_]+$/.test(edge)) continue;
+        stmts.push(`${selectFields} FROM ${id}->${edge}->? LIMIT 3`);
+        stmts.push(`${selectFields} FROM ${id}<-${edge}<-? LIMIT 3`);
+      }
+    }
+    let allQueryResults;
+    try {
+      allQueryResults = await store.queryBatch(stmts, bindings);
+    } catch (e) {
+      swallow.warn("causal:batch", e);
+      break;
+    }
+    const nextFrontier = [];
+    for (const rows of allQueryResults) {
+      for (const row of rows) {
+        const nodeId = String(row.id);
+        if (seen.has(nodeId)) continue;
+        seen.add(nodeId);
+        const text = row.text ?? "";
+        if (text) {
+          results.push({
+            id: nodeId,
+            text,
+            score: row.score ?? 0,
+            importance: row.importance,
+            accessCount: row.accessCount,
+            timestamp: row.timestamp,
+            table: String(row.table ?? "memory"),
+            source: row.category
+          });
+          if (RECORD_ID_RE.test(nodeId)) {
+            nextFrontier.push(nodeId);
+          }
+        }
+      }
+    }
+    frontier = nextFrontier.slice(0, 5);
+  }
+  if (results.length > 0 && minConfidence > 0) {
+    const resultIds = results.map((r) => r.id);
+    try {
+      const chains = await store.queryFirst(
+        `SELECT trigger_memory, outcome_memory, confidence FROM causal_chain
+         WHERE confidence >= $minConf AND (trigger_memory IN $ids OR outcome_memory IN $ids)`,
+        { minConf: minConfidence, ids: resultIds }
+      );
+      const allowedIds = /* @__PURE__ */ new Set();
+      for (const c of chains) {
+        allowedIds.add(String(c.trigger_memory));
+        allowedIds.add(String(c.outcome_memory));
+      }
+      return results.filter((r) => allowedIds.has(r.id));
+    } catch (e) {
+      swallow.warn("causal:confidence-filter", e);
+      return results;
+    }
+  }
+  return results;
+}
+async function getSessionCausalChains(sessionId, store) {
+  try {
+    if (!store.isAvailable()) return { count: 0, successRate: 0 };
+    const rows = await store.queryFirst(
+      `SELECT count() AS total, math::sum(IF success THEN 1 ELSE 0 END) AS successes
+       FROM causal_chain WHERE session_id = $sid GROUP ALL`,
+      { sid: sessionId }
+    );
+    const row = rows[0];
+    if (!row || !row.total) return { count: 0, successRate: 0 };
+    return {
+      count: Number(row.total),
+      successRate: Number(row.successes) / Number(row.total)
+    };
+  } catch (e) {
+    swallow("causal:metrics", e);
+    return { count: 0, successRate: 0 };
+  }
+}
+
+export {
+  linkCausalEdges,
+  queryCausalContext,
+  getSessionCausalChains
+};

package/dist/chunk-B3QUPMCI.js

@@ -0,0 +1,419 @@
+import {
+  assertRecordId,
+  init_errors,
+  swallow
+} from "./chunk-XSIONAGJ.js";
+
+// src/memory-daemon.ts
+init_errors();
+
+// src/concept-extract.ts
+init_errors();
+async function linkToRelevantConcepts(sourceId, edgeName, text, store, embeddings, logTag, limit = 5, threshold = 0.65, precomputedVec) {
+  if (!embeddings.isAvailable() || !text) return;
+  try {
+    const vec = precomputedVec?.length ? precomputedVec : await embeddings.embed(text);
+    if (!vec?.length) return;
+    const matches = await store.queryFirst(
+      `SELECT id, vector::similarity::cosine(embedding, $vec) AS score
+       FROM concept
+       WHERE embedding != NONE AND array::len(embedding) > 0
+         AND embedding_provider = $provider
+       ORDER BY score DESC
+       LIMIT $lim`,
+      { vec, lim: limit, provider: embeddings.providerId }
+    );
+    for (const m of matches) {
+      if (m.score < threshold) break;
+      await store.relate(sourceId, edgeName, String(m.id)).catch((e) => swallow(`${logTag}:relate`, e));
+    }
+  } catch (e) {
+    swallow(`${logTag}:embed`, e);
+  }
+}
+async function linkConceptHierarchy(conceptId, conceptName, store, embeddings, logTag) {
+  try {
+    const existing = await store.queryFirst(
+      `SELECT id, content FROM concept WHERE id != $cid LIMIT 50`,
+      { cid: conceptId }
+    );
+    if (existing.length === 0) return;
+    const lowerName = conceptName.toLowerCase();
+    let relatedCount = 0;
+    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) {
+        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) {
+        await store.relate(conceptId, "broader", otherId).catch((e) => swallow(`${logTag}:broader`, e));
+        await store.relate(otherId, "narrower", conceptId).catch((e) => swallow(`${logTag}:narrower`, e));
+      }
+    }
+    if (embeddings.isAvailable()) {
+      try {
+        const conceptEmb = await embeddings.embed(conceptName);
+        if (conceptEmb?.length) {
+          const similar = await store.queryFirst(
+            `SELECT id, vector::similarity::cosine(embedding, $vec) AS score
+             FROM concept
+             WHERE id != $cid
+               AND embedding != NONE AND array::len(embedding) > 0
+               AND embedding_provider = $provider
+             ORDER BY score DESC
+             LIMIT 3`,
+            { vec: conceptEmb, cid: conceptId, provider: embeddings.providerId }
+          );
+          for (const s of similar) {
+            if (s.score < 0.75) break;
+            const simId = String(s.id);
+            await store.relate(conceptId, "related_to", simId).catch((e) => swallow(`${logTag}:related_to`, e));
+            await store.relate(simId, "related_to", conceptId).catch((e) => swallow(`${logTag}:related_to`, e));
+          }
+        }
+      } catch (e) {
+        swallow(`${logTag}:related_to_search`, e);
+      }
+    }
+  } catch (e) {
+    swallow(`${logTag}:hierarchy`, e);
+  }
+}
+
+// src/memory-daemon.ts
+function buildSystemPrompt(hasThinking, hasRetrievedMemories, prior) {
+  const dedup = prior.conceptNames.length > 0 || prior.artifactPaths.length > 0 || prior.skillNames.length > 0 ? `
+
+ALREADY EXTRACTED (do NOT repeat these):
+- Concepts: ${prior.conceptNames.length > 0 ? prior.conceptNames.join(", ") : "none yet"}
+- Artifacts: ${prior.artifactPaths.length > 0 ? prior.artifactPaths.join(", ") : "none yet"}
+- Skills: ${prior.skillNames.length > 0 ? prior.skillNames.join(", ") : "none yet"}` : "";
+  return `You are a memory extraction daemon. Analyze the conversation transcript and extract structured knowledge.
+Return ONLY valid JSON with these fields (all arrays, use [] if none found for a field):
+${dedup}
+
+{
+  "causal": [
+    // Cause->effect chains from debugging, refactoring, fixing, or building.
+    // Only when there's a clear trigger and outcome. Max 5.
+    {"triggerText": "what caused it (max 200 chars)", "outcomeText": "what happened as a result", "chainType": "debug|refactor|feature|fix", "success": true/false, "confidence": 0.0-1.0, "description": "1-sentence summary"}
+  ],
+  "monologue": [
+    // Internal reasoning moments worth preserving: doubts, tradeoffs, insights, realizations.
+    // Infer from the conversation flow \u2014 approach changes, surprising discoveries, tradeoff decisions.
+    // Skip routine reasoning. Only novel/surprising thoughts. Max 5.
+    {"category": "doubt|tradeoff|alternative|insight|realization", "content": "1-2 sentence description"}
+  ],
+${hasRetrievedMemories ? `  "resolved": [
+    // IDs from [RETRIEVED MEMORIES] that have been FULLY addressed/fixed/completed in this conversation.
+    // Must be exact IDs like "memory:abc123". Empty [] if none resolved.
+    "memory:example_id"
+  ],` : '  "resolved": [],'}
+  "concepts": [
+    // Technical facts, knowledge, decisions, or findings worth remembering.
+    // NOT conversation flow \u2014 only things that would be useful to recall later.
+    // Categories: technical, architectural, behavioral, environmental, procedural
+    // Max 8 per batch.
+    {"name": "short identifier (3-6 words)", "content": "the actual knowledge (1-3 sentences)", "category": "technical|architectural|behavioral|environmental|procedural", "importance": 1-10}
+  ],
+  "corrections": [
+    // Moments where the user corrects the assistant's understanding, approach, or output.
+    // These are high-value signals about what NOT to do.
+    {"original": "what the assistant said/did wrong", "correction": "what the user said the right answer/approach is", "context": "brief context of when this happened"}
+  ],
+  "preferences": [
+    // User behavioral signals: communication style, workflow preferences, tool preferences.
+    // Only extract NOVEL preferences not already obvious. Max 5.
+    {"preference": "what the user prefers (1 sentence)", "evidence": "what they said/did that shows this"}
+  ],
+  "artifacts": [
+    // Files that were created, modified, read, or discussed.
+    // Extract from tool calls (bash, read, write, edit, grep commands).
+    {"path": "/path/to/file", "action": "created|modified|read|discussed", "summary": "what was done to it (1 sentence)"}
+  ],
+  "decisions": [
+    // Explicit choices made during the conversation with reasoning.
+    // Architecture decisions, tool choices, approach selections. Max 3.
+    {"decision": "what was decided", "rationale": "why", "alternatives_considered": "what else was considered (or 'none discussed')"}
+  ],
+  "skills": [
+    // Reusable multi-step procedures that WORKED. Only extract when a procedure
+    // was successfully completed and would be useful to repeat. Max 2.
+    {"name": "short name", "steps": ["step 1", "step 2", "..."], "trigger_context": "when to use this skill"}
+  ]
+}
+
+RULES:
+- Return ONLY the JSON object. No markdown, no explanation.
+- Every field must be present (use [] for empty).
+- Quality over quantity \u2014 skip weak/uncertain extractions.
+- Concepts should be self-contained \u2014 readable without the conversation.
+- Corrections are the MOST important signal. Never miss one.
+- For artifacts, extract file paths from bash/tool commands in the transcript.`;
+}
+function buildTranscript(turns) {
+  return turns.map((t) => {
+    const prefix = t.tool_name ? `[tool:${t.tool_name}]` : `[${t.role}]`;
+    let line = `${prefix} ${(t.text ?? "").slice(0, 1500)}`;
+    if (t.tool_result) line += `
+  -> ${t.tool_result.slice(0, 500)}`;
+    if (t.file_paths && t.file_paths.length > 0) line += `
+  files: ${t.file_paths.join(", ")}`;
+    return line;
+  }).join("\n");
+}
+async function writeExtractionResults(result, sessionId, store, embeddings, priorState, taskId, projectId, turns) {
+  const counts = {
+    causal: 0,
+    monologue: 0,
+    resolved: 0,
+    concept: 0,
+    correction: 0,
+    preference: 0,
+    artifact: 0,
+    decision: 0,
+    skill: 0
+  };
+  const extractedConceptIds = [];
+  if (Array.isArray(result.concepts) && result.concepts.length > 0) {
+    for (const c of result.concepts.slice(0, 11)) {
+      if (!c.name || !c.content) continue;
+      if (priorState.conceptNames.includes(c.name)) continue;
+      counts.concept++;
+      priorState.conceptNames.push(c.name);
+      try {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(c.content);
+          } catch (e) {
+            swallow("daemon:embedConcept", e);
+          }
+        }
+        const conceptId = await store.upsertConcept(c.content, emb, `daemon:${sessionId}`);
+        if (conceptId) {
+          extractedConceptIds.push(conceptId);
+          await linkConceptHierarchy(conceptId, c.name, store, embeddings, "daemon:concept");
+          if (taskId) {
+            await store.relate(conceptId, "derived_from", taskId).catch((e) => swallow("daemon:concept:derived_from", e));
+          }
+          if (projectId) {
+            await store.relate(conceptId, "relevant_to", projectId).catch((e) => swallow("daemon:concept:relevant_to", e));
+          }
+        }
+      } catch (e) {
+        swallow.warn("daemon:upsertConcept", e);
+      }
+    }
+  }
+  if (turns && turns.length > 0) {
+    const turnIds = turns.filter((t) => t.turnId && t.text).slice(0, 15);
+    for (const t of turnIds) {
+      await linkToRelevantConcepts(
+        t.turnId,
+        "mentions",
+        t.text,
+        store,
+        embeddings,
+        "daemon:mentions",
+        5,
+        0.65
+      );
+    }
+  }
+  const writeOps = [];
+  if (Array.isArray(result.causal) && result.causal.length > 0) {
+    const { linkCausalEdges } = await import("./causal-CZ62YZ2J.js");
+    const validated = result.causal.filter((c) => c.triggerText && c.outcomeText && c.chainType && typeof c.success === "boolean").slice(0, 5).map((c) => ({
+      triggerText: String(c.triggerText).slice(0, 200),
+      outcomeText: String(c.outcomeText).slice(0, 200),
+      chainType: ["debug", "refactor", "feature", "fix"].includes(c.chainType) ? c.chainType : "fix",
+      success: Boolean(c.success),
+      confidence: Math.max(0, Math.min(1, Number(c.confidence) || 0.5)),
+      description: String(c.description ?? "").slice(0, 150)
+    }));
+    if (validated.length > 0) {
+      writeOps.push(linkCausalEdges(validated, sessionId, store, embeddings));
+      counts.causal += validated.length;
+    }
+  }
+  if (Array.isArray(result.monologue) && result.monologue.length > 0) {
+    for (const entry of result.monologue.slice(0, 5)) {
+      if (!entry.category || !entry.content) continue;
+      counts.monologue++;
+      writeOps.push((async () => {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(entry.content);
+          } catch (e) {
+            swallow("daemon:embedMonologue", e);
+          }
+        }
+        await store.createMonologue(sessionId, entry.category, entry.content, emb);
+      })());
+    }
+  }
+  if (Array.isArray(result.resolved) && result.resolved.length > 0) {
+    const RECORD_ID_RE = /^memory:[a-zA-Z0-9_]+$/;
+    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++;
+        await store.queryExec(
+          `UPDATE ${memId} SET status = 'resolved', resolved_at = time::now(), resolved_by = $sid`,
+          { sid: sessionId }
+        ).catch((e) => swallow.warn("daemon:resolveMemory", e));
+      }
+    })());
+  }
+  if (Array.isArray(result.corrections) && result.corrections.length > 0) {
+    for (const c of result.corrections.slice(0, 5)) {
+      if (!c.original || !c.correction) continue;
+      counts.correction++;
+      const text = `[CORRECTION] Original: "${String(c.original).slice(0, 200)}" -> Corrected: "${String(c.correction).slice(0, 200)}" (Context: ${String(c.context ?? "").slice(0, 100)})`;
+      writeOps.push((async () => {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(text);
+          } catch (e) {
+            swallow("daemon:embedCorrection", e);
+          }
+        }
+        const memId = await store.createMemory(text, emb, 9, "correction", sessionId);
+        if (memId) {
+          await linkToRelevantConcepts(memId, "about_concept", text, store, embeddings, "daemon:correction:about_concept", 5, 0.65, emb);
+        }
+      })());
+    }
+  }
+  if (Array.isArray(result.preferences) && result.preferences.length > 0) {
+    for (const p of result.preferences.slice(0, 5)) {
+      if (!p.preference) continue;
+      counts.preference++;
+      const text = `[USER PREFERENCE] ${String(p.preference).slice(0, 250)} (Evidence: ${String(p.evidence ?? "").slice(0, 150)})`;
+      writeOps.push((async () => {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(text);
+          } catch (e) {
+            swallow("daemon:embedPreference", e);
+          }
+        }
+        const memId = await store.createMemory(text, emb, 7, "preference", sessionId);
+        if (memId) {
+          await linkToRelevantConcepts(memId, "about_concept", text, store, embeddings, "daemon:preference:about_concept", 5, 0.65, emb);
+        }
+      })());
+    }
+  }
+  if (Array.isArray(result.artifacts) && result.artifacts.length > 0) {
+    for (const a of result.artifacts.slice(0, 10)) {
+      if (!a.path) continue;
+      if (priorState.artifactPaths.includes(a.path)) continue;
+      counts.artifact++;
+      priorState.artifactPaths.push(a.path);
+      const desc = `${String(a.action ?? "modified")}: ${String(a.summary ?? "").slice(0, 200)}`;
+      writeOps.push((async () => {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(`${a.path} ${desc}`);
+          } catch (e) {
+            swallow("daemon:embedArtifact", e);
+          }
+        }
+        const artId = await store.createArtifact(a.path, a.action ?? "modified", desc, emb);
+        if (artId) {
+          await linkToRelevantConcepts(artId, "artifact_mentions", `${a.path} ${desc}`, store, embeddings, "daemon:artifact:artifact_mentions", 5, 0.65, emb);
+          if (projectId) {
+            await store.relate(artId, "used_in", projectId).catch((e) => swallow("daemon:artifact:used_in", e));
+          }
+        }
+      })());
+    }
+  }
+  if (Array.isArray(result.decisions) && result.decisions.length > 0) {
+    for (const d of result.decisions.slice(0, 6)) {
+      if (!d.decision) continue;
+      counts.decision++;
+      const text = `[DECISION] ${String(d.decision).slice(0, 200)} \u2014 Rationale: ${String(d.rationale ?? "").slice(0, 200)} (Alternatives: ${String(d.alternatives_considered ?? "none").slice(0, 100)})`;
+      writeOps.push((async () => {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(text);
+          } catch (e) {
+            swallow("daemon:embedDecision", e);
+          }
+        }
+        const memId = await store.createMemory(text, emb, 7, "decision", sessionId);
+        if (memId) {
+          await linkToRelevantConcepts(memId, "about_concept", text, store, embeddings, "daemon:decision:about_concept", 5, 0.65, emb);
+        }
+      })());
+    }
+  }
+  if (Array.isArray(result.skills) && result.skills.length > 0) {
+    for (const s of result.skills.slice(0, 3)) {
+      if (!s.name || !Array.isArray(s.steps) || s.steps.length === 0) continue;
+      if (priorState.skillNames.includes(s.name)) continue;
+      counts.skill++;
+      priorState.skillNames.push(s.name);
+      const content = `${s.name}
+Trigger: ${String(s.trigger_context ?? "").slice(0, 150)}
+Steps:
+${s.steps.map((st, i) => `${i + 1}. ${String(st).slice(0, 200)}`).join("\n")}`;
+      writeOps.push((async () => {
+        let emb = null;
+        if (embeddings.isAvailable()) {
+          try {
+            emb = await embeddings.embed(content);
+          } catch (e) {
+            swallow("daemon:embedSkill", e);
+          }
+        }
+        try {
+          const rows = await store.queryFirst(
+            `CREATE skill CONTENT $record RETURN id`,
+            {
+              record: {
+                name: String(s.name).slice(0, 100),
+                description: content,
+                content,
+                steps: s.steps.map((st) => String(st).slice(0, 200)),
+                trigger_context: String(s.trigger_context ?? "").slice(0, 200),
+                tags: ["auto-extracted"],
+                session_id: sessionId,
+                ...emb ? { embedding: emb, embedding_provider: embeddings.providerId } : {}
+              }
+            }
+          );
+          const skillId = rows[0]?.id ? String(rows[0].id) : null;
+          if (skillId) {
+            if (taskId) {
+              await store.relate(skillId, "skill_from_task", taskId).catch((e) => swallow.warn("daemon:skill:skill_from_task", e));
+            }
+            await linkToRelevantConcepts(skillId, "skill_uses_concept", content, store, embeddings, "daemon:skill:concepts", 5, 0.65, emb);
+          }
+        } catch (e) {
+          swallow.warn("daemon:createSkill", e);
+        }
+      })());
+    }
+  }
+  await Promise.allSettled(writeOps);
+  return counts;
+}
+
+export {
+  linkToRelevantConcepts,
+  buildSystemPrompt,
+  buildTranscript,
+  writeExtractionResults
+};