@cleocode/core 2026.4.50 → 2026.4.52

package/dist/internal.js

@@ -9069,12 +9069,13 @@ __export(brain_schema_exports, {
   brainPageEdges: () => brainPageEdges,
   brainPageNodes: () => brainPageNodes,
   brainPatterns: () => brainPatterns,
+  brainPlasticityEvents: () => brainPlasticityEvents,
   brainRetrievalLog: () => brainRetrievalLog,
   brainSchemaMeta: () => brainSchemaMeta,
   brainStickyNotes: () => brainStickyNotes
 });
 import { sql as sql2 } from "drizzle-orm";
-var BRAIN_MEMORY_TIERS, BRAIN_COGNITIVE_TYPES, BRAIN_SOURCE_CONFIDENCE, BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES2, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, BRAIN_STICKY_STATUSES, BRAIN_STICKY_COLORS, BRAIN_STICKY_PRIORITIES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainStickyNotes, brainMemoryLinks, brainSchemaMeta, BRAIN_NODE_TYPES, BRAIN_EDGE_TYPES, brainPageNodes, brainPageEdges, brainRetrievalLog;
+var BRAIN_MEMORY_TIERS, BRAIN_COGNITIVE_TYPES, BRAIN_SOURCE_CONFIDENCE, BRAIN_DECISION_TYPES, BRAIN_CONFIDENCE_LEVELS, BRAIN_OUTCOME_TYPES, BRAIN_PATTERN_TYPES, BRAIN_IMPACT_LEVELS, BRAIN_LINK_TYPES, BRAIN_OBSERVATION_TYPES2, BRAIN_OBSERVATION_SOURCE_TYPES, BRAIN_MEMORY_TYPES, BRAIN_STICKY_STATUSES, BRAIN_STICKY_COLORS, BRAIN_STICKY_PRIORITIES, brainDecisions, brainPatterns, brainLearnings, brainObservations, brainStickyNotes, brainMemoryLinks, brainSchemaMeta, BRAIN_NODE_TYPES, BRAIN_EDGE_TYPES, brainPageNodes, brainPageEdges, brainRetrievalLog, brainPlasticityEvents;
 var init_brain_schema = __esm({
   "packages/core/src/store/brain-schema.ts"() {
     "use strict";
@@ -9503,8 +9504,11 @@ var init_brain_schema = __esm({
       // Graph bridging (memory ↔ code)
       "references",
       // observation → references → symbol
-      "modified_by"
+      "modified_by",
       // file → modified_by → session
+      // Plasticity (Hebbian + STDP co-retrieval)
+      "co_retrieved"
+      // A → co_retrieved → B (Hebbian: frequently retrieved together)
     ];
     brainPageNodes = sqliteTable(
       "brain_page_nodes",
@@ -9594,11 +9598,45 @@ var init_brain_schema = __esm({
         source: text("source").notNull(),
         /** Estimated tokens consumed by this retrieval. */
         tokensUsed: integer("tokens_used"),
+        /** Session ID (soft FK to tasks.db sessions). Enables grouping retrievals by session for STDP analysis. */
+        sessionId: text("session_id"),
         createdAt: text("created_at").notNull().default(sql2`(datetime('now'))`)
       },
       (table) => [
         index("idx_retrieval_log_created").on(table.createdAt),
-        index("idx_retrieval_log_source").on(table.source)
+        index("idx_retrieval_log_source").on(table.source),
+        index("idx_retrieval_log_session").on(table.sessionId)
+      ]
+    );
+    brainPlasticityEvents = sqliteTable(
+      "brain_plasticity_events",
+      {
+        id: integer("id").primaryKey({ autoIncrement: true }),
+        /** from_id of the affected brain_page_edges row. */
+        sourceNode: text("source_node").notNull(),
+        /** to_id of the affected brain_page_edges row. */
+        targetNode: text("target_node").notNull(),
+        /**
+         * Signed weight delta applied to the edge.
+         * Positive = potentiation (LTP), negative = depression (LTD).
+         */
+        deltaW: real("delta_w").notNull(),
+        /**
+         * STDP event kind: `ltp` (Long-Term Potentiation) or `ltd` (Long-Term
+         * Depression).
+         */
+        kind: text("kind", { enum: ["ltp", "ltd"] }).notNull(),
+        /** ISO 8601 timestamp when this event was applied. */
+        timestamp: text("timestamp").notNull().default(sql2`(datetime('now'))`),
+        /** Session ID that triggered the STDP pass, if available. */
+        sessionId: text("session_id")
+      },
+      (table) => [
+        index("idx_plasticity_source").on(table.sourceNode),
+        index("idx_plasticity_target").on(table.targetNode),
+        index("idx_plasticity_timestamp").on(table.timestamp),
+        index("idx_plasticity_session").on(table.sessionId),
+        index("idx_plasticity_kind").on(table.kind)
       ]
     );
   }
@@ -14915,7 +14953,7 @@ function clearEmbeddingProvider() {
   currentProvider = null;
 }
 async function embedText(text3) {
-  if (!currentProvider || !currentProvider.isAvailable()) return null;
+  if (!currentProvider?.isAvailable()) return null;
   return currentProvider.embed(text3);
 }
 function isEmbeddingAvailable() {
@@ -15012,6 +15050,14 @@ function runBrainMigrations(nativeDb, db) {
     );
   }
   ensureColumns(nativeDb, "brain_observations", [{ name: "agent", ddl: "text" }], "brain");
+  if (tableExists(nativeDb, "brain_page_edges")) {
+    nativeDb.prepare(
+      `UPDATE brain_page_edges
+         SET edge_type = 'co_retrieved'
+         WHERE edge_type = 'relates_to'
+           AND provenance LIKE 'consolidation:%'`
+    ).run();
+  }
 }
 function loadBrainVecExtension(nativeDb) {
   try {
@@ -20057,7 +20103,7 @@ function parseIdPrefix(id) {
   return null;
 }
 async function searchSimilar(query, projectRoot, limit) {
-  if (!query || !query.trim()) return [];
+  if (!query?.trim()) return [];
   if (!isEmbeddingAvailable()) return [];
   const maxResults = limit ?? 10;
   const queryVector = await embedText(query);
@@ -21692,6 +21738,160 @@ var init_anthropic_key_resolver = __esm({
   }
 });
 
+// packages/core/src/memory/decision-cross-link.ts
+function extractReferencedSymbols(text3) {
+  const seen = /* @__PURE__ */ new Set();
+  const refs = [];
+  for (const match of text3.matchAll(FILE_PATH_RE)) {
+    const raw = match[1];
+    if (!raw) continue;
+    const nodeId = `file:${raw}`;
+    if (seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    refs.push({ raw, nodeId, nodeType: "file", label: raw });
+  }
+  for (const match of text3.matchAll(SYMBOL_RE)) {
+    const raw = match[0];
+    if (!raw || raw.length < 4) continue;
+    if (SYMBOL_STOP_WORDS.has(raw.toLowerCase())) continue;
+    const nodeId = `symbol:${raw}`;
+    if (seen.has(nodeId)) continue;
+    seen.add(nodeId);
+    refs.push({ raw, nodeId, nodeType: "symbol", label: raw });
+  }
+  return refs;
+}
+async function linkDecisionToTargets(projectRoot, decisionId, refs) {
+  const fromId = `decision:${decisionId}`;
+  const writes = refs.map(async (ref) => {
+    await upsertGraphNode(
+      projectRoot,
+      ref.nodeId,
+      ref.nodeType,
+      ref.label,
+      0.5,
+      // placeholder quality until nexus indexes it
+      ref.raw
+    );
+    await addGraphEdge(
+      projectRoot,
+      fromId,
+      ref.nodeId,
+      "applies_to",
+      1,
+      "auto:decision-cross-link"
+    );
+  });
+  await Promise.allSettled(writes);
+}
+async function autoCrossLinkDecision(projectRoot, decisionId, decisionText, rationale) {
+  try {
+    const combined = `${decisionText} ${rationale}`;
+    const refs = extractReferencedSymbols(combined);
+    if (refs.length === 0) return;
+    await linkDecisionToTargets(projectRoot, decisionId, refs);
+  } catch {
+  }
+}
+var FILE_PATH_RE, SYMBOL_RE, SYMBOL_STOP_WORDS;
+var init_decision_cross_link = __esm({
+  "packages/core/src/memory/decision-cross-link.ts"() {
+    "use strict";
+    init_graph_auto_populate();
+    FILE_PATH_RE = /(?:^|[\s`"'([\]{,])((\/[\w.\-/]+|[\w.-]+(?:\/[\w.-]+)+)\.(ts|tsx|js|jsx|rs|json))(?=$|[\s`"')[\]{,])/gm;
+    SYMBOL_RE = /(?<![`"'/\w.])(?:[A-Z][a-zA-Z0-9]{2,}|[a-z][a-zA-Z0-9]*(?:[A-Z][a-zA-Z0-9]*)+|[a-z][a-z0-9]*(?:_[a-z][a-z0-9]*){2,})(?![`"'/\w])/g;
+    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+      "this",
+      "that",
+      "with",
+      "from",
+      "into",
+      "when",
+      "then",
+      "also",
+      "both",
+      "each",
+      "such",
+      "over",
+      "after",
+      "before",
+      "always",
+      "never",
+      "should",
+      "must",
+      "will",
+      "would",
+      "could",
+      "have",
+      "been",
+      "there",
+      "their",
+      "they",
+      "them",
+      "these",
+      "those",
+      "some",
+      "only",
+      "just",
+      "more",
+      "most",
+      "many",
+      "much",
+      "well",
+      "very",
+      "here",
+      "where",
+      "which",
+      "what",
+      "why",
+      "how",
+      "the",
+      "and",
+      "but",
+      "for",
+      "not",
+      "are",
+      "was",
+      "were",
+      "has",
+      "had",
+      "its",
+      "the",
+      "data",
+      "true",
+      "false",
+      "null",
+      "none",
+      "type",
+      "test",
+      "spec",
+      "todo",
+      "fixme",
+      "note",
+      "example",
+      "index",
+      "config",
+      "error",
+      "value",
+      "input",
+      "output",
+      "result",
+      "return",
+      "default",
+      "source",
+      "target",
+      "import",
+      "export",
+      "class",
+      "interface",
+      "function",
+      "const",
+      "async",
+      "await"
+    ]);
+  }
+});
+
 // packages/core/src/memory/decisions.ts
 var decisions_exports = {};
 __export(decisions_exports, {
@@ -21830,6 +22030,8 @@ async function storeDecision(projectRoot, params) {
         "auto:store-decision"
       );
     }
+    autoCrossLinkDecision(projectRoot, saved.id, saved.decision, saved.rationale).catch(() => {
+    });
   } catch {
   }
   detectSupersession(projectRoot, {
@@ -21898,6 +22100,7 @@ var init_decisions2 = __esm({
     init_brain_accessor();
     init_cross_db_cleanup();
     init_sqlite2();
+    init_decision_cross_link();
     init_graph_auto_populate();
     init_quality_scoring();
     init_temporal_supersession();
@@ -42968,6 +43171,30 @@ var init_auto_extract = __esm({
   }
 });
 
+// packages/core/src/memory/edge-types.ts
+var EDGE_TYPES;
+var init_edge_types = __esm({
+  "packages/core/src/memory/edge-types.ts"() {
+    "use strict";
+    EDGE_TYPES = {
+      // Plasticity (Hebbian / STDP co-retrieval)
+      CO_RETRIEVED: "co_retrieved",
+      // Temporal supersession
+      SUPERSEDES: "supersedes",
+      // Task / decision / pattern → target context
+      APPLIES_TO: "applies_to",
+      // Provenance
+      DERIVED_FROM: "derived_from",
+      // Observation → symbol/file impact
+      AFFECTS: "affects",
+      // Observation → symbol name mention
+      MENTIONS: "mentions",
+      // Observation → symbol/file structural link
+      DOCUMENTS: "documents"
+    };
+  }
+});
+
 // packages/core/src/memory/brain-consolidator.ts
 var brain_consolidator_exports = {};
 __export(brain_consolidator_exports, {
@@ -43201,7 +43428,7 @@ function extractSymbolCandidates(text3) {
   const syms = /* @__PURE__ */ new Set();
   for (const m2 of text3.matchAll(SYMBOL_PATTERN)) {
     const s3 = m2[1];
-    if (s3 && s3.length >= 4 && !SYMBOL_STOP_WORDS.has(s3.toLowerCase())) {
+    if (s3 && s3.length >= 4 && !SYMBOL_STOP_WORDS2.has(s3.toLowerCase())) {
       syms.add(s3);
     }
   }
@@ -43510,7 +43737,7 @@ async function listCodeLinks(projectRoot, limit = 100) {
   }
   return entries;
 }
-var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS;
+var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS2;
 var init_graph_memory_bridge = __esm({
   "packages/core/src/memory/graph-memory-bridge.ts"() {
     "use strict";
@@ -43520,7 +43747,7 @@ var init_graph_memory_bridge = __esm({
     init_typed_query();
     FILE_PATH_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_\-./]+\.(?:ts|tsx|js|jsx|rs|go|py|mjs|cjs))(?:$|\s|['"`)])/g;
     SYMBOL_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*(?:[A-Z][a-zA-Z0-9_]*)+|[a-zA-Z_]{4,}[a-zA-Z0-9_]*)\b/g;
-    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+    SYMBOL_STOP_WORDS2 = /* @__PURE__ */ new Set([
       "true",
       "false",
       "null",
@@ -43564,6 +43791,207 @@ var init_graph_memory_bridge = __esm({
   }
 });
 
+// packages/core/src/memory/brain-stdp.ts
+var brain_stdp_exports = {};
+__export(brain_stdp_exports, {
+  applyStdpPlasticity: () => applyStdpPlasticity,
+  getPlasticityStats: () => getPlasticityStats
+});
+async function applyStdpPlasticity(projectRoot, sessionWindowMs = 5 * 60 * 1e3) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  const result = {
+    ltpEvents: 0,
+    ltdEvents: 0,
+    edgesCreated: 0,
+    pairsExamined: 0
+  };
+  if (!nativeDb) return result;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_retrieval_log LIMIT 1").get();
+  } catch {
+    return result;
+  }
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_plasticity_events LIMIT 1").get();
+  } catch {
+    return result;
+  }
+  const now2 = Date.now();
+  const cutoffMs = now2 - sessionWindowMs;
+  const cutoffIso = new Date(cutoffMs).toISOString().replace("T", " ").slice(0, 19);
+  const nowIso = new Date(now2).toISOString().replace("T", " ").slice(0, 19);
+  let logRows = [];
+  try {
+    logRows = typedAll(
+      nativeDb.prepare(
+        `SELECT id, entry_ids, created_at, retrieval_order, delta_ms
+         FROM brain_retrieval_log
+         WHERE created_at >= ?
+         ORDER BY created_at ASC, id ASC
+         LIMIT 2000`
+      ),
+      cutoffIso
+    );
+  } catch {
+    return result;
+  }
+  if (logRows.length === 0) return result;
+  const spikes = [];
+  let globalOrder = 0;
+  for (const row of logRows) {
+    let ids;
+    try {
+      ids = JSON.parse(row.entry_ids);
+    } catch {
+      continue;
+    }
+    const rowTime = (/* @__PURE__ */ new Date(row.created_at.replace(" ", "T") + "Z")).getTime();
+    for (const rawId of ids) {
+      const entryId = rawId.includes(":") ? rawId : `observation:${rawId}`;
+      spikes.push({
+        entryId,
+        rowId: row.id,
+        retrievedAt: rowTime,
+        order: row.retrieval_order ?? globalOrder
+      });
+      globalOrder++;
+    }
+  }
+  spikes.sort((a, b2) => a.retrievedAt - b2.retrievedAt || a.order - b2.order);
+  const prepareGetEdge = nativeDb.prepare(
+    `SELECT weight FROM brain_page_edges
+     WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
+  );
+  const prepareUpdateEdge = nativeDb.prepare(
+    `UPDATE brain_page_edges
+     SET weight = MAX(?, MIN(?, weight + ?))
+     WHERE from_id = ? AND to_id = ? AND edge_type = 'co_retrieved'`
+  );
+  const prepareInsertEdge = nativeDb.prepare(
+    `INSERT OR IGNORE INTO brain_page_edges
+       (from_id, to_id, edge_type, weight, provenance, created_at)
+     VALUES (?, ?, 'co_retrieved', ?, 'plasticity:stdp-ltp', ?)`
+  );
+  const prepareLogEvent = nativeDb.prepare(
+    `INSERT INTO brain_plasticity_events
+       (source_node, target_node, delta_w, kind, timestamp)
+     VALUES (?, ?, ?, ?, ?)`
+  );
+  for (let i = 0; i < spikes.length; i++) {
+    const spikeA = spikes[i];
+    for (let j2 = i + 1; j2 < spikes.length; j2++) {
+      const spikeB = spikes[j2];
+      const deltaT = spikeB.retrievedAt - spikeA.retrievedAt;
+      if (deltaT > sessionWindowMs) break;
+      if (spikeA.entryId === spikeB.entryId) continue;
+      result.pairsExamined++;
+      const deltaW = A_PRE * Math.exp(-deltaT / TAU_PRE_MS);
+      if (deltaW < 1e-6) continue;
+      const existingEdge = prepareGetEdge.get(spikeA.entryId, spikeB.entryId);
+      try {
+        if (existingEdge !== void 0) {
+          prepareUpdateEdge.run(WEIGHT_MIN, WEIGHT_MAX, deltaW, spikeA.entryId, spikeB.entryId);
+        } else {
+          const initialWeight = Math.min(WEIGHT_MAX, deltaW);
+          prepareInsertEdge.run(spikeA.entryId, spikeB.entryId, initialWeight, nowIso);
+          result.edgesCreated++;
+        }
+        prepareLogEvent.run(spikeA.entryId, spikeB.entryId, deltaW, "ltp", nowIso);
+        result.ltpEvents++;
+      } catch {
+      }
+      const deltaWNeg = -(A_POST * Math.exp(-deltaT / TAU_POST_MS));
+      const existingReverseEdge = prepareGetEdge.get(spikeB.entryId, spikeA.entryId);
+      if (existingReverseEdge !== void 0 && Math.abs(deltaWNeg) >= 1e-6) {
+        try {
+          prepareUpdateEdge.run(WEIGHT_MIN, WEIGHT_MAX, deltaWNeg, spikeB.entryId, spikeA.entryId);
+          prepareLogEvent.run(spikeB.entryId, spikeA.entryId, deltaWNeg, "ltd", nowIso);
+          result.ltdEvents++;
+        } catch {
+        }
+      }
+    }
+  }
+  return result;
+}
+async function getPlasticityStats(projectRoot, limit = 20) {
+  const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
+  await getBrainDb2(projectRoot);
+  const nativeDb = getBrainNativeDb2();
+  const empty = {
+    totalEvents: 0,
+    ltpCount: 0,
+    ltdCount: 0,
+    netDeltaW: 0,
+    lastEventAt: null,
+    recentEvents: []
+  };
+  if (!nativeDb) return empty;
+  try {
+    nativeDb.prepare("SELECT 1 FROM brain_plasticity_events LIMIT 1").get();
+  } catch {
+    return empty;
+  }
+  let agg;
+  try {
+    agg = nativeDb.prepare(
+      `SELECT
+           COUNT(*)                         AS total,
+           SUM(CASE WHEN kind = 'ltp' THEN 1 ELSE 0 END) AS ltp_count,
+           SUM(CASE WHEN kind = 'ltd' THEN 1 ELSE 0 END) AS ltd_count,
+           SUM(delta_w)                    AS net_delta_w,
+           MAX(timestamp)                  AS last_event_at
+         FROM brain_plasticity_events`
+    ).get();
+  } catch {
+    return empty;
+  }
+  let recentRows = [];
+  try {
+    recentRows = typedAll(
+      nativeDb.prepare(
+        `SELECT id, source_node, target_node, delta_w, kind, timestamp, session_id
+         FROM brain_plasticity_events
+         ORDER BY timestamp DESC, id DESC
+         LIMIT ?`
+      ),
+      limit
+    );
+  } catch {
+  }
+  return {
+    totalEvents: agg?.total ?? 0,
+    ltpCount: agg?.ltp_count ?? 0,
+    ltdCount: agg?.ltd_count ?? 0,
+    netDeltaW: agg?.net_delta_w ?? 0,
+    lastEventAt: agg?.last_event_at ?? null,
+    recentEvents: recentRows.map((r) => ({
+      id: r.id,
+      sourceNode: r.source_node,
+      targetNode: r.target_node,
+      deltaW: r.delta_w,
+      kind: r.kind,
+      timestamp: r.timestamp,
+      sessionId: r.session_id
+    }))
+  };
+}
+var TAU_PRE_MS, TAU_POST_MS, A_PRE, A_POST, WEIGHT_MIN, WEIGHT_MAX;
+var init_brain_stdp = __esm({
+  "packages/core/src/memory/brain-stdp.ts"() {
+    "use strict";
+    init_typed_query();
+    TAU_PRE_MS = 2e4;
+    TAU_POST_MS = 2e4;
+    A_PRE = 0.05;
+    A_POST = 0.06;
+    WEIGHT_MIN = 0;
+    WEIGHT_MAX = 1;
+  }
+});
+
 // packages/core/src/memory/brain-lifecycle.ts
 var brain_lifecycle_exports = {};
 __export(brain_lifecycle_exports, {
@@ -43869,6 +44297,13 @@ async function runConsolidation(projectRoot) {
   } catch (err) {
     console.warn("[consolidation] Step 8 graph memory bridge failed:", err);
   }
+  try {
+    const { applyStdpPlasticity: applyStdpPlasticity2 } = await Promise.resolve().then(() => (init_brain_stdp(), brain_stdp_exports));
+    const stdpResult = await applyStdpPlasticity2(projectRoot);
+    result.stdpPlasticity = stdpResult;
+  } catch (err) {
+    console.warn("[consolidation] Step 9 STDP plasticity failed:", err);
+  }
   return result;
 }
 async function deduplicateByEmbedding(projectRoot) {
@@ -44030,16 +44465,16 @@ async function strengthenCoRetrievedEdges(projectRoot) {
       const updateStmt = nativeDb.prepare(`
         UPDATE brain_page_edges
         SET weight = MIN(1.0, weight + 0.1)
-        WHERE from_id = ? AND to_id = ? AND edge_type = 'relates_to'
+        WHERE from_id = ? AND to_id = ? AND edge_type = ?
       `);
-      const updateResult = updateStmt.run(nodeFrom, nodeTo);
+      const updateResult = updateStmt.run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED);
       const changes = typeof updateResult.changes === "number" ? updateResult.changes : 0;
       if (changes === 0) {
         nativeDb.prepare(`
             INSERT OR IGNORE INTO brain_page_edges
               (from_id, to_id, edge_type, weight, provenance, created_at)
-            VALUES (?, ?, 'relates_to', 0.3, 'consolidation:co-retrieval', ?)
-          `).run(nodeFrom, nodeTo, now2);
+            VALUES (?, ?, ?, 0.3, 'consolidation:co-retrieval', ?)
+          `).run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED, now2);
       }
       strengthened++;
     } catch {
@@ -44053,6 +44488,7 @@ var init_brain_lifecycle = __esm({
     "use strict";
     init_brain_accessor();
     init_typed_query();
+    init_edge_types();
     STOP_WORDS3 = /* @__PURE__ */ new Set([
       "the",
       "a",
@@ -47214,7 +47650,7 @@ async function computeLastSession(projectRoot, scopeFilter) {
     const accessor = await getAccessor(projectRoot);
     const allSessions = await accessor.loadSessions();
     const session = allSessions.find((s3) => s3.id === sessionId);
-    if (!session || !session.endedAt) return null;
+    if (!session?.endedAt) return null;
     let duration3 = 0;
     if (session.startedAt) {
       duration3 = Math.round(
@@ -48401,10 +48837,17 @@ async function searchBrainCompact(projectRoot, params) {
       setImmediate(() => {
         incrementCitationCounts(projectRoot, returnedIds).catch(() => {
         });
-        logRetrieval(projectRoot, query, returnedIds, "find-rrf", results2.length * 50).catch(
-          () => {
-          }
-        );
+        getCurrentSessionId(projectRoot).then((sessionId) => {
+          return logRetrieval(
+            projectRoot,
+            query,
+            returnedIds,
+            "find-rrf",
+            results2.length * 50,
+            sessionId
+          );
+        }).catch(() => {
+        });
       });
     }
     return { results: results2, total: results2.length, tokensEstimated: results2.length * 50 };
@@ -48467,7 +48910,16 @@ async function searchBrainCompact(projectRoot, params) {
     setImmediate(() => {
       incrementCitationCounts(projectRoot, returnedIds).catch(() => {
       });
-      logRetrieval(projectRoot, query, returnedIds, "find", results.length * 50).catch(() => {
+      getCurrentSessionId(projectRoot).then((sessionId) => {
+        return logRetrieval(
+          projectRoot,
+          query,
+          returnedIds,
+          "find",
+          results.length * 50,
+          sessionId
+        );
+      }).catch(() => {
       });
     });
   }
@@ -48655,13 +49107,16 @@ async function fetchBrainEntries(projectRoot, params) {
     setImmediate(() => {
       incrementCitationCounts(projectRoot, fetchedIds).catch(() => {
       });
-      logRetrieval(
-        projectRoot,
-        fetchedIds.join(","),
-        fetchedIds,
-        "fetch",
-        results.length * 500
-      ).catch(() => {
+      getCurrentSessionId(projectRoot).then((sessionId) => {
+        return logRetrieval(
+          projectRoot,
+          fetchedIds.join(","),
+          fetchedIds,
+          "fetch",
+          results.length * 500,
+          sessionId
+        );
+      }).catch(() => {
       });
     });
   }
@@ -49079,6 +49534,15 @@ async function retrieveWithBudget(projectRoot, query, tokenBudget = 500, options
     excluded
   };
 }
+async function getCurrentSessionId(projectRoot) {
+  try {
+    const { sessionStatus: sessionStatus2 } = await Promise.resolve().then(() => (init_sessions2(), sessions_exports2));
+    const session = await sessionStatus2(projectRoot);
+    return session?.id;
+  } catch {
+    return void 0;
+  }
+}
 async function incrementCitationCounts(projectRoot, ids) {
   if (ids.length === 0) return;
   const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
@@ -49105,13 +49569,13 @@ async function incrementCitationCounts(projectRoot, ids) {
     }
   }
 }
-async function logRetrieval(projectRoot, query, entryIds, source, tokensUsed) {
+async function logRetrieval(projectRoot, query, entryIds, source, tokensUsed, sessionId) {
   if (entryIds.length === 0) return;
   const { getBrainDb: getBrainDb2, getBrainNativeDb: getBrainNativeDb2 } = await Promise.resolve().then(() => (init_brain_sqlite(), brain_sqlite_exports));
   await getBrainDb2(projectRoot);
   const nativeDb = getBrainNativeDb2();
   if (!nativeDb) return;
-  const createSql = "CREATE TABLE IF NOT EXISTS brain_retrieval_log (id INTEGER PRIMARY KEY AUTOINCREMENT,query TEXT NOT NULL,entry_ids TEXT NOT NULL,entry_count INTEGER NOT NULL,source TEXT NOT NULL,tokens_used INTEGER,created_at TEXT NOT NULL DEFAULT (datetime('now')))";
+  const createSql = "CREATE TABLE IF NOT EXISTS brain_retrieval_log (id INTEGER PRIMARY KEY AUTOINCREMENT,query TEXT NOT NULL,entry_ids TEXT NOT NULL,entry_count INTEGER NOT NULL,source TEXT NOT NULL,tokens_used INTEGER,session_id TEXT,created_at TEXT NOT NULL DEFAULT (datetime('now')))";
   try {
     nativeDb.prepare(createSql).run();
   } catch {
@@ -49119,8 +49583,15 @@ async function logRetrieval(projectRoot, query, entryIds, source, tokensUsed) {
   }
   try {
     nativeDb.prepare(
-      "INSERT INTO brain_retrieval_log (query, entry_ids, entry_count, source, tokens_used) VALUES (?, ?, ?, ?, ?)"
-    ).run(query, entryIds.join(","), entryIds.length, source, tokensUsed ?? null);
+      "INSERT INTO brain_retrieval_log (query, entry_ids, entry_count, source, tokens_used, session_id) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(
+      query,
+      entryIds.join(","),
+      entryIds.length,
+      source,
+      tokensUsed ?? null,
+      sessionId ?? null
+    );
   } catch {
   }
 }
@@ -72404,7 +72875,7 @@ function prepareSpawnMulti(skillNames, tokenValues, cwd) {
     const skillName = skillNames[i];
     const isPrimary = i === 0;
     const skill = findSkill(skillName, cwd);
-    if (!skill || !skill.content) {
+    if (!skill?.content) {
       continue;
     }
     let content = isPrimary ? skill.content : loadProgressive(skill.content);
@@ -73091,6 +73562,7 @@ async function listEpicsWithLifecycle(cwd) {
 // packages/core/src/memory/index.ts
 var memory_exports = {};
 __export(memory_exports, {
+  EDGE_TYPES: () => EDGE_TYPES,
   RRF_K: () => RRF_K,
   addResearch: () => addResearch,
   appendExtendedManifest: () => appendExtendedManifest,
@@ -73288,6 +73760,7 @@ function mapImpact(impact) {
 init_brain_retrieval();
 init_brain_search();
 init_decisions2();
+init_edge_types();
 
 // packages/core/src/memory/extraction-gate.ts
 init_brain_embedding();
@@ -81673,6 +82146,7 @@ async function getSyncStatus(remote = "origin", cwd) {
 // packages/core/src/research/index.ts
 var research_exports = {};
 __export(research_exports, {
+  EDGE_TYPES: () => EDGE_TYPES,
   RRF_K: () => RRF_K,
   addResearch: () => addResearch,
   appendExtendedManifest: () => appendExtendedManifest,
@@ -84063,7 +84537,7 @@ async function injectProtocol(skillContent, taskId, tokenValues, cwd, tier) {
 }
 async function orchestratorSpawnSkill(taskId, skillName, tokenValues, cwd, tier) {
   const skill = findSkill(skillName, cwd);
-  if (!skill || !skill.content) {
+  if (!skill?.content) {
     throw new CleoError(4 /* NOT_FOUND */, `Skill not found: ${skillName}`, {
       fix: `Check skills directory for ${skillName}/SKILL.md`
     });
@@ -84599,7 +85073,7 @@ async function buildPrompt(taskId, templateName = "TASK-EXECUTOR", cwd, tier) {
     throw new CleoError(4 /* NOT_FOUND */, `Task ${taskId} not found`);
   }
   const skill = findSkill(templateName, cwd);
-  if (!skill || !skill.content) {
+  if (!skill?.content) {
     const { canonical } = mapSkillName(templateName);
     throw new CleoError(4 /* NOT_FOUND */, `Skill template ${templateName} not found`, {
       fix: `Expected at skills/${canonical}/SKILL.md`
@@ -87099,7 +87573,7 @@ async function analyzeArchive(opts, accessor) {
   const acc = accessor ?? await getAccessor(opts.cwd);
   const data = await acc.loadArchive();
   const reportType = opts.report ?? "summary";
-  if (!data || !data.archivedTasks?.length) {
+  if (!data?.archivedTasks?.length) {
     return {
       report: reportType,
       filters: null,
@@ -93030,16 +93504,12 @@ function allEpicChildrenVerified(epicId, tasks2) {
   if (children.length === 0) return false;
   const incomplete = children.filter((t) => t.status !== "done");
   if (incomplete.length > 0) return false;
-  const unverified = children.filter(
-    (t) => t.status === "done" && (!t.verification || !t.verification.passed)
-  );
+  const unverified = children.filter((t) => t.status === "done" && !t.verification?.passed);
   return unverified.length === 0;
 }
 function allSiblingsVerified(parentId, tasks2) {
   const siblings = tasks2.filter((t) => t.parentId === parentId);
-  const unverifiedDone = siblings.filter(
-    (t) => t.status === "done" && (!t.verification || !t.verification.passed)
-  );
+  const unverifiedDone = siblings.filter((t) => t.status === "done" && !t.verification?.passed);
   const incomplete = siblings.filter(
     (t) => t.status === "pending" || t.status === "active" || t.status === "blocked"
   );
@@ -93417,7 +93887,7 @@ import { randomUUID as randomUUID8 } from "node:crypto";
 init_paths();
 import { existsSync as existsSync109, readFileSync as readFileSync77, writeFileSync as writeFileSync20 } from "node:fs";
 import { join as join108 } from "node:path";
-function getCurrentSessionId(cwd) {
+function getCurrentSessionId2(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
   const sessionFile = join108(getCleoDir(cwd), ".current-session");
   if (existsSync109(sessionFile)) {
@@ -93445,7 +93915,7 @@ function createCliMeta(operation, duration_ms = 0) {
     duration_ms,
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const sessionId = getCurrentSessionId();
+  const sessionId = getCurrentSessionId2();
   if (sessionId) {
     meta3["sessionId"] = sessionId;
   }
@@ -96947,6 +97417,155 @@ async function backfillBrainGraph(projectRoot) {
   };
 }
 
+// packages/core/src/memory/brain-export.ts
+init_brain_schema();
+init_brain_sqlite();
+async function exportBrainAsGexf(projectRoot) {
+  const db = await getBrainDb(projectRoot);
+  let nodes = [];
+  let edges = [];
+  try {
+    nodes = await db.select({
+      id: brainPageNodes.id,
+      nodeType: brainPageNodes.nodeType,
+      label: brainPageNodes.label,
+      qualityScore: brainPageNodes.qualityScore,
+      contentHash: brainPageNodes.contentHash,
+      lastActivityAt: brainPageNodes.lastActivityAt,
+      metadataJson: brainPageNodes.metadataJson,
+      createdAt: brainPageNodes.createdAt,
+      updatedAt: brainPageNodes.updatedAt
+    }).from(brainPageNodes);
+  } catch {
+    nodes = [];
+  }
+  try {
+    const rawEdges = await db.select({
+      fromId: brainPageEdges.fromId,
+      toId: brainPageEdges.toId,
+      edgeType: brainPageEdges.edgeType,
+      weight: brainPageEdges.weight,
+      createdAt: brainPageEdges.createdAt
+    }).from(brainPageEdges);
+    edges = rawEdges.map((e) => ({ ...e, provenance: null }));
+  } catch {
+    edges = [];
+  }
+  const gexf = buildGexfDocument(nodes, edges);
+  return {
+    success: true,
+    format: "gexf",
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    content: gexf,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function exportBrainAsJson(projectRoot) {
+  const db = await getBrainDb(projectRoot);
+  let nodes = [];
+  let edges = [];
+  try {
+    nodes = await db.select({
+      id: brainPageNodes.id,
+      nodeType: brainPageNodes.nodeType,
+      label: brainPageNodes.label,
+      qualityScore: brainPageNodes.qualityScore,
+      contentHash: brainPageNodes.contentHash,
+      lastActivityAt: brainPageNodes.lastActivityAt,
+      metadataJson: brainPageNodes.metadataJson,
+      createdAt: brainPageNodes.createdAt,
+      updatedAt: brainPageNodes.updatedAt
+    }).from(brainPageNodes);
+  } catch {
+    nodes = [];
+  }
+  try {
+    const rawEdges = await db.select({
+      fromId: brainPageEdges.fromId,
+      toId: brainPageEdges.toId,
+      edgeType: brainPageEdges.edgeType,
+      weight: brainPageEdges.weight,
+      createdAt: brainPageEdges.createdAt
+    }).from(brainPageEdges);
+    edges = rawEdges.map((e) => ({ ...e, provenance: null }));
+  } catch {
+    edges = [];
+  }
+  return {
+    success: true,
+    format: "json",
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    nodes,
+    edges,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildGexfDocument(nodes, edges) {
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<gexf xmlns="http://www.gexf.net/1.3draft" version="1.3">',
+    '  <meta lastmodifieddate="' + (/* @__PURE__ */ new Date()).toISOString() + '">',
+    "    <creator>CLEO Brain Export (T626-M6)</creator>",
+    "    <description>Living brain knowledge graph (brain_page_nodes + brain_page_edges)</description>",
+    "  </meta>",
+    '  <graph mode="static" defaultedgetype="directed">'
+  ];
+  lines.push('    <attributes class="node">');
+  lines.push('      <attribute id="node_type" title="Node Type" type="string"/>');
+  lines.push('      <attribute id="quality_score" title="Quality Score" type="double"/>');
+  lines.push('      <attribute id="content_hash" title="Content Hash" type="string"/>');
+  lines.push('      <attribute id="last_activity_at" title="Last Activity" type="string"/>');
+  lines.push('      <attribute id="created_at" title="Created At" type="string"/>');
+  lines.push("    </attributes>");
+  lines.push('    <attributes class="edge">');
+  lines.push('      <attribute id="edge_type" title="Edge Type" type="string"/>');
+  lines.push('      <attribute id="provenance" title="Provenance" type="string"/>');
+  lines.push('      <attribute id="created_at" title="Created At" type="string"/>');
+  lines.push("    </attributes>");
+  lines.push("    <nodes>");
+  for (const node of nodes) {
+    lines.push(`      <node id="${escapeXml(node.id)}" label="${escapeXml(node.label)}">`);
+    lines.push("        <attvalues>");
+    lines.push(`          <attvalue for="node_type" value="${escapeXml(node.nodeType)}"/>`);
+    lines.push(`          <attvalue for="quality_score" value="${node.qualityScore ?? 0.5}"/>`);
+    if (node.contentHash) {
+      lines.push(`          <attvalue for="content_hash" value="${escapeXml(node.contentHash)}"/>`);
+    }
+    lines.push(
+      `          <attvalue for="last_activity_at" value="${escapeXml(node.lastActivityAt)}"/>`
+    );
+    lines.push(`          <attvalue for="created_at" value="${escapeXml(node.createdAt)}"/>`);
+    lines.push("        </attvalues>");
+    lines.push("      </node>");
+  }
+  lines.push("    </nodes>");
+  lines.push("    <edges>");
+  for (let i = 0; i < edges.length; i++) {
+    const edge = edges[i];
+    const weight = edge.weight ?? 1;
+    lines.push(
+      `      <edge id="${i}" source="${escapeXml(edge.fromId)}" target="${escapeXml(edge.toId)}" weight="${weight}">`
+    );
+    lines.push("        <attvalues>");
+    lines.push(`          <attvalue for="edge_type" value="${escapeXml(edge.edgeType)}"/>`);
+    if (edge.provenance) {
+      lines.push(`          <attvalue for="provenance" value="${escapeXml(edge.provenance)}"/>`);
+    }
+    lines.push(`          <attvalue for="created_at" value="${escapeXml(edge.createdAt)}"/>`);
+    lines.push("        </attvalues>");
+    lines.push("      </edge>");
+  }
+  lines.push("    </edges>");
+  lines.push("  </graph>");
+  lines.push("</gexf>");
+  return lines.join("\n");
+}
+function escapeXml(text3) {
+  return text3.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
 // packages/core/src/internal.ts
 init_brain_lifecycle();
 
@@ -97190,6 +97809,7 @@ async function purgeBrainNoise(projectRoot) {
 
 // packages/core/src/internal.ts
 init_brain_retrieval();
+init_brain_stdp();
 
 // packages/core/src/memory/claude-mem-migration.ts
 init_paths();
@@ -97365,7 +97985,7 @@ Use --source <path> to specify a custom location.`
       }
       try {
         for (const row of batch) {
-          if (!row.learned || !row.learned.trim()) {
+          if (!row.learned?.trim()) {
             continue;
           }
           const learnId = `CML-${row.id}`;
@@ -103723,7 +104343,7 @@ function measureDependencyDepth(taskId, taskMap, visited = /* @__PURE__ */ new S
   if (visited.has(taskId)) return 0;
   visited.add(taskId);
   const task = taskMap.get(taskId);
-  if (!task || !task.depends || task.depends.length === 0) return 0;
+  if (!task?.depends || task.depends.length === 0) return 0;
   let maxDepth = 0;
   for (const depId of task.depends) {
     const depth = 1 + measureDependencyDepth(depId, taskMap, visited);
@@ -104077,7 +104697,7 @@ async function coreTaskUnarchive(projectRoot, taskId, params) {
     throw new Error(`Task '${taskId}' already exists in active tasks`);
   }
   const archive = await accessor.loadArchive();
-  if (!archive || !archive.archivedTasks) {
+  if (!archive?.archivedTasks) {
     throw new Error("No archive file found");
   }
   const taskIndex = archive.archivedTasks.findIndex((t) => t.id === taskId);
@@ -110309,6 +110929,7 @@ export {
   analyzeDependencies2 as analyzeDependencies,
   analyzeEpic,
   analyzeTaskImpact,
+  applyStdpPlasticity,
   applyStrictnessPreset,
   applyTemporalDecay,
   archiveSessions,
@@ -110522,6 +111143,8 @@ export {
   ensureSqliteDb,
   estimateContext,
   executeTransfer,
+  exportBrainAsGexf,
+  exportBrainAsJson,
   exportSnapshot,
   exportTasks,
   exportTasksPackage,
@@ -110591,7 +111214,7 @@ export {
   getConfigValue,
   getContextDrift,
   getCriticalPath,
-  getCurrentSessionId,
+  getCurrentSessionId2 as getCurrentSessionId,
   getDashboard,
   getDb,
   getDecisionLog,
@@ -110636,6 +111259,7 @@ export {
   getPackageRoot,
   getParallelStatus,
   getPipelineStageOrder,
+  getPlasticityStats,
   getProjectAgentRef2 as getProjectAgentRef,
   getProjectInfo,
   getProjectInfoSync,