@cleocode/core 2026.4.50 → 2026.4.52

package/src/memory/__tests__/decision-cross-link.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Tests for decision-cross-link module.
+ *
+ * Covers:
+ *  - extractReferencedSymbols: file-path detection, symbol detection, dedup,
+ *    stop-word filtering, short-name filtering.
+ *  - linkDecisionToTargets: verifies edges are written to brain_page_edges
+ *    when autoCapture is enabled.
+ *  - autoCrossLinkDecision: end-to-end smoke test (never throws).
+ *
+ * @task T626
+ * @epic T626
+ */
+
+import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let tempDir: string;
+let cleoDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), 'cleo-decision-cross-link-'));
+  cleoDir = join(tempDir, '.cleo');
+  await mkdir(cleoDir, { recursive: true });
+  process.env['CLEO_DIR'] = cleoDir;
+});
+
+afterEach(async () => {
+  const { closeBrainDb } = await import('../../store/brain-sqlite.js');
+  closeBrainDb();
+  delete process.env['CLEO_DIR'];
+  await rm(tempDir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// extractReferencedSymbols
+// ---------------------------------------------------------------------------
+
+describe('extractReferencedSymbols', () => {
+  it('extracts a relative TypeScript file path', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols('Changed src/store/brain-schema.ts to add new column');
+    const fileRefs = refs.filter((r) => r.nodeType === 'file');
+    expect(fileRefs.length).toBeGreaterThanOrEqual(1);
+    expect(fileRefs.some((r) => r.raw === 'src/store/brain-schema.ts')).toBe(true);
+  });
+
+  it('extracts an absolute TypeScript file path', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols(
+      'See /mnt/projects/cleocode/packages/core/src/memory/decisions.ts for details',
+    );
+    const fileRefs = refs.filter((r) => r.nodeType === 'file');
+    expect(fileRefs.some((r) => r.raw.endsWith('decisions.ts'))).toBe(true);
+  });
+
+  it('extracts a PascalCase class reference', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols('BrainDataAccessor must expose the new query method');
+    const symRefs = refs.filter((r) => r.nodeType === 'symbol');
+    expect(symRefs.some((r) => r.raw === 'BrainDataAccessor')).toBe(true);
+  });
+
+  it('extracts a camelCase function reference', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols('Call upsertGraphNode before addGraphEdge');
+    const symRefs = refs.filter((r) => r.nodeType === 'symbol');
+    const names = symRefs.map((r) => r.raw);
+    expect(names).toContain('upsertGraphNode');
+    expect(names).toContain('addGraphEdge');
+  });
+
+  it('deduplicates identical references', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols(
+      'upsertGraphNode is called twice: upsertGraphNode for nodes, upsertGraphNode for edges',
+    );
+    const symRefs = refs.filter((r) => r.raw === 'upsertGraphNode');
+    expect(symRefs).toHaveLength(1);
+  });
+
+  it('filters out stop-words', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    // "always", "should", "never" are in the stop-word list
+    const refs = extractReferencedSymbols('always should never with this that from into');
+    const symRefs = refs.filter((r) => r.nodeType === 'symbol');
+    const names = symRefs.map((r) => r.raw.toLowerCase());
+    expect(names).not.toContain('always');
+    expect(names).not.toContain('should');
+    expect(names).not.toContain('never');
+  });
+
+  it('filters out symbols shorter than 4 characters', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols('Use DB to store it');
+    const symRefs = refs.filter((r) => r.nodeType === 'symbol' && r.raw.length < 4);
+    expect(symRefs).toHaveLength(0);
+  });
+
+  it('returns empty array for plain-English text with no references', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols('We decided to use a relational database.');
+    // May have some false positives for symbols, but no file refs
+    const fileRefs = refs.filter((r) => r.nodeType === 'file');
+    expect(fileRefs).toHaveLength(0);
+  });
+
+  it('assigns correct nodeIds', async () => {
+    const { extractReferencedSymbols } = await import('../decision-cross-link.js');
+    const refs = extractReferencedSymbols(
+      'Updated src/memory/decisions.ts and called storeDecision',
+    );
+    const fileRef = refs.find((r) => r.nodeType === 'file');
+    const symRef = refs.find((r) => r.nodeType === 'symbol' && r.raw === 'storeDecision');
+    expect(fileRef?.nodeId).toMatch(/^file:/);
+    expect(symRef?.nodeId).toBe('symbol:storeDecision');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// linkDecisionToTargets — graph writes
+// ---------------------------------------------------------------------------
+
+describe('linkDecisionToTargets', () => {
+  it('creates applies_to edges in brain_page_edges when autoCapture is enabled', async () => {
+    // Stub shouldAutoPopulateGraph to return true by setting autoCapture config
+    // The easiest approach: write a minimal config.json so isAutoCaptureEnabled returns true
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(join(cleoDir, 'config.json'), JSON.stringify({ brain: { autoCapture: true } }));
+
+    const { closeBrainDb, getBrainDb } = await import('../../store/brain-sqlite.js');
+    closeBrainDb();
+
+    // Initialise DB
+    const db = await getBrainDb(tempDir);
+
+    const { extractReferencedSymbols, linkDecisionToTargets } = await import(
+      '../decision-cross-link.js'
+    );
+    const { brainPageEdges } = await import('../../store/brain-schema.js');
+
+    const refs = extractReferencedSymbols(
+      'Refactored src/store/brain-schema.ts to add BrainPageNodes column',
+    );
+    expect(refs.length).toBeGreaterThan(0);
+
+    await linkDecisionToTargets(tempDir, 'D001', refs);
+
+    // Check that at least one applies_to edge was created
+    const edges = await db.select().from(brainPageEdges);
+    const affectsEdges = edges.filter(
+      (e) => e.fromId === 'decision:D001' && e.edgeType === 'applies_to',
+    );
+    expect(affectsEdges.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('is a no-op when refs array is empty', async () => {
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(join(cleoDir, 'config.json'), JSON.stringify({ brain: { autoCapture: true } }));
+
+    const { closeBrainDb, getBrainDb } = await import('../../store/brain-sqlite.js');
+    closeBrainDb();
+    const db = await getBrainDb(tempDir);
+    const { brainPageEdges } = await import('../../store/brain-schema.js');
+
+    const { linkDecisionToTargets } = await import('../decision-cross-link.js');
+    await linkDecisionToTargets(tempDir, 'D001', []);
+
+    const edges = await db.select().from(brainPageEdges);
+    expect(edges.filter((e) => e.fromId === 'decision:D001')).toHaveLength(0);
+  });
+
+  it('does not throw when autoCapture is disabled', async () => {
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(
+      join(cleoDir, 'config.json'),
+      JSON.stringify({ brain: { autoCapture: false } }),
+    );
+
+    const { closeBrainDb } = await import('../../store/brain-sqlite.js');
+    closeBrainDb();
+
+    const { extractReferencedSymbols, linkDecisionToTargets } = await import(
+      '../decision-cross-link.js'
+    );
+    const refs = extractReferencedSymbols('Changed src/store/brain-schema.ts');
+    // Should not throw even when autoCapture is off
+    await expect(linkDecisionToTargets(tempDir, 'D001', refs)).resolves.toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// autoCrossLinkDecision — convenience facade
+// ---------------------------------------------------------------------------
+
+describe('autoCrossLinkDecision', () => {
+  it('never throws for any input', async () => {
+    const { autoCrossLinkDecision } = await import('../decision-cross-link.js');
+
+    // Should not throw even without a DB or config
+    await expect(
+      autoCrossLinkDecision(tempDir, 'D001', 'some decision text', 'some rationale'),
+    ).resolves.toBeUndefined();
+
+    // Empty strings
+    await expect(autoCrossLinkDecision(tempDir, 'D001', '', '')).resolves.toBeUndefined();
+  });
+
+  it('creates edges when decision text mentions a known file path', async () => {
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(join(cleoDir, 'config.json'), JSON.stringify({ brain: { autoCapture: true } }));
+
+    const { closeBrainDb, getBrainDb } = await import('../../store/brain-sqlite.js');
+    closeBrainDb();
+    const db = await getBrainDb(tempDir);
+    const { brainPageEdges } = await import('../../store/brain-schema.js');
+
+    const { autoCrossLinkDecision } = await import('../decision-cross-link.js');
+    await autoCrossLinkDecision(
+      tempDir,
+      'D042',
+      'Use packages/core/src/memory/decisions.ts as the write gate',
+      'Centralises all decision writes in one module',
+    );
+
+    const edges = await db.select().from(brainPageEdges);
+    const decisionsEdges = edges.filter(
+      (e) =>
+        e.fromId === 'decision:D042' && e.edgeType === 'applies_to' && e.toId.startsWith('file:'),
+    );
+    expect(decisionsEdges.length).toBeGreaterThanOrEqual(1);
+  });
+});

package/src/memory/brain-embedding.ts

@@ -56,7 +56,7 @@ export function clearEmbeddingProvider(): void {
  * Returns null when no provider is set or not available (FTS5-only fallback).
  */
 export async function embedText(text: string): Promise<Float32Array | null> {
-  if (!currentProvider || !currentProvider.isAvailable()) return null;
+  if (!currentProvider?.isAvailable()) return null;
   return currentProvider.embed(text);
 }
 

package/src/memory/brain-export.ts

@@ -0,0 +1,286 @@
+/**
+ * Brain graph export functionality — GEXF (Gephi standard) and JSON formats.
+ *
+ * Exports brain_page_nodes and brain_page_edges as:
+ * - GEXF XML: Gephi-compatible graph interchange format with attributes
+ * - JSON: Flat array representation for tooling integration
+ *
+ * @task T626-M6
+ * @epic T626
+ */
+
+import type { BrainPageEdgeRow, BrainPageNodeRow } from '../store/brain-schema.js';
+import * as brainSchema from '../store/brain-schema.js';
+import { getBrainDb } from '../store/brain-sqlite.js';
+
+/**
+ * GEXF export result with XML content.
+ */
+export interface BrainExportGexfResult {
+  success: boolean;
+  format: 'gexf';
+  nodeCount: number;
+  edgeCount: number;
+  content: string;
+  generatedAt: string;
+}
+
+/**
+ * JSON export result with nodes and edges arrays.
+ */
+export interface BrainExportJsonResult {
+  success: boolean;
+  format: 'json';
+  nodeCount: number;
+  edgeCount: number;
+  nodes: BrainPageNodeRow[];
+  edges: BrainPageEdgeRow[];
+  generatedAt: string;
+}
+
+export type BrainExportResult = BrainExportGexfResult | BrainExportJsonResult;
+
+/**
+ * Export brain graph as GEXF XML (Gephi standard format).
+ *
+ * Generates a valid GEXF 1.3 document with:
+ * - Node elements with attributes (type, quality, label)
+ * - Edge elements with weight and provenance
+ * - Static, directed graph
+ *
+ * @param projectRoot - Root directory of the CLEO project
+ * @returns GEXF XML export result
+ *
+ * @example
+ * ```ts
+ * const result = await exportBrainAsGexf('/path/to/project');
+ * console.log(result.content); // Valid XML for import into Gephi
+ * ```
+ */
+export async function exportBrainAsGexf(projectRoot: string): Promise<BrainExportGexfResult> {
+  const db = await getBrainDb(projectRoot);
+
+  // Fetch all nodes and edges using basic select without provenance column
+  // This handles older schemas gracefully
+  let nodes: BrainPageNodeRow[] = [];
+  let edges: BrainPageEdgeRow[] = [];
+
+  try {
+    nodes = await db
+      .select({
+        id: brainSchema.brainPageNodes.id,
+        nodeType: brainSchema.brainPageNodes.nodeType,
+        label: brainSchema.brainPageNodes.label,
+        qualityScore: brainSchema.brainPageNodes.qualityScore,
+        contentHash: brainSchema.brainPageNodes.contentHash,
+        lastActivityAt: brainSchema.brainPageNodes.lastActivityAt,
+        metadataJson: brainSchema.brainPageNodes.metadataJson,
+        createdAt: brainSchema.brainPageNodes.createdAt,
+        updatedAt: brainSchema.brainPageNodes.updatedAt,
+      })
+      .from(brainSchema.brainPageNodes);
+  } catch {
+    // If the graph nodes table doesn't exist, default to empty
+    nodes = [];
+  }
+
+  try {
+    // Select edges without the provenance column to handle older schemas
+    const rawEdges = await db
+      .select({
+        fromId: brainSchema.brainPageEdges.fromId,
+        toId: brainSchema.brainPageEdges.toId,
+        edgeType: brainSchema.brainPageEdges.edgeType,
+        weight: brainSchema.brainPageEdges.weight,
+        createdAt: brainSchema.brainPageEdges.createdAt,
+      })
+      .from(brainSchema.brainPageEdges);
+    // Add provenance as null for missing rows and cast to the full row type
+    edges = rawEdges.map((e) => ({ ...e, provenance: null }) as BrainPageEdgeRow);
+  } catch {
+    // If that fails, default to empty
+    edges = [];
+  }
+
+  // Build GEXF document
+  const gexf = buildGexfDocument(nodes, edges);
+
+  return {
+    success: true,
+    format: 'gexf',
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    content: gexf,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Export brain graph as JSON.
+ *
+ * Outputs nodes and edges as flat arrays for programmatic processing.
+ * Suitable for visualization libraries and data integration.
+ *
+ * @param projectRoot - Root directory of the CLEO project
+ * @returns JSON export result with nodes and edges arrays
+ *
+ * @example
+ * ```ts
+ * const result = await exportBrainAsJson('/path/to/project');
+ * console.log(JSON.stringify(result, null, 2)); // Pretty-printed JSON
+ * ```
+ */
+export async function exportBrainAsJson(projectRoot: string): Promise<BrainExportJsonResult> {
+  const db = await getBrainDb(projectRoot);
+
+  // Fetch all nodes and edges using basic select without provenance column
+  // This handles older schemas gracefully
+  let nodes: BrainPageNodeRow[] = [];
+  let edges: BrainPageEdgeRow[] = [];
+
+  try {
+    nodes = await db
+      .select({
+        id: brainSchema.brainPageNodes.id,
+        nodeType: brainSchema.brainPageNodes.nodeType,
+        label: brainSchema.brainPageNodes.label,
+        qualityScore: brainSchema.brainPageNodes.qualityScore,
+        contentHash: brainSchema.brainPageNodes.contentHash,
+        lastActivityAt: brainSchema.brainPageNodes.lastActivityAt,
+        metadataJson: brainSchema.brainPageNodes.metadataJson,
+        createdAt: brainSchema.brainPageNodes.createdAt,
+        updatedAt: brainSchema.brainPageNodes.updatedAt,
+      })
+      .from(brainSchema.brainPageNodes);
+  } catch {
+    // If the graph nodes table doesn't exist, default to empty
+    nodes = [];
+  }
+
+  try {
+    // Select edges without the provenance column to handle older schemas
+    const rawEdges = await db
+      .select({
+        fromId: brainSchema.brainPageEdges.fromId,
+        toId: brainSchema.brainPageEdges.toId,
+        edgeType: brainSchema.brainPageEdges.edgeType,
+        weight: brainSchema.brainPageEdges.weight,
+        createdAt: brainSchema.brainPageEdges.createdAt,
+      })
+      .from(brainSchema.brainPageEdges);
+    // Add provenance as null for missing rows and cast to the full row type
+    edges = rawEdges.map((e) => ({ ...e, provenance: null }) as BrainPageEdgeRow);
+  } catch {
+    // If that fails, default to empty
+    edges = [];
+  }
+
+  return {
+    success: true,
+    format: 'json',
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    nodes,
+    edges,
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Build a GEXF 1.3 XML document from nodes and edges.
+ *
+ * GEXF structure:
+ * - gexf@xmlns, @version
+ * - graph@mode=static, @defaultedgetype=directed
+ * - nodes with attvalues (node_type, quality_score, label)
+ * - edges with attributes (edge_type, weight, provenance)
+ *
+ * @param nodes - Array of brain page nodes
+ * @param edges - Array of brain page edges
+ * @returns Valid GEXF 1.3 XML string
+ */
+function buildGexfDocument(nodes: BrainPageNodeRow[], edges: BrainPageEdgeRow[]): string {
+  const lines: string[] = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<gexf xmlns="http://www.gexf.net/1.3draft" version="1.3">',
+    '  <meta lastmodifieddate="' + 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">',
+  ];
+
+  // Define node attributes schema
+  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>');
+
+  // Define edge attributes schema
+  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>');
+
+  // Add nodes
+  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>');
+
+  // Add edges
+  lines.push('    <edges>');
+  for (let i = 0; i < edges.length; i++) {
+    const edge = edges[i];
+    const weight = edge.weight ?? 1.0;
+    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');
+}
+
+/**
+ * Escape XML special characters to prevent injection/parsing errors.
+ *
+ * @param text - Text to escape
+ * @returns XML-safe string
+ */
+function escapeXml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}

package/src/memory/brain-lifecycle.ts

@@ -21,6 +21,7 @@ import { createHash } from 'node:crypto';
 import { getBrainAccessor } from '../store/brain-accessor.js';
 import { typedAll } from '../store/typed-query.js';
 import type { BrainConsolidationObservationRow } from './brain-row-types.js';
+import { EDGE_TYPES } from './edge-types.js';
 
 /** Result from applying temporal decay. */
 export interface DecayResult {
@@ -592,6 +593,13 @@ export interface RunConsolidationResult {
   summariesGenerated: number;
   /** Code↔memory graph links created. */
   graphLinksCreated?: number;
+  /** STDP plasticity result from step 9. */
+  stdpPlasticity?: {
+    ltpEvents: number;
+    ltdEvents: number;
+    edgesCreated: number;
+    pairsExamined: number;
+  };
 }
 
 /**
@@ -695,6 +703,17 @@ export async function runConsolidation(projectRoot: string): Promise<RunConsolid
     console.warn('[consolidation] Step 8 graph memory bridge failed:', err);
   }
 
+  // Step 9: STDP timing-dependent plasticity (T626 phase 5)
+  // Refines co_retrieved edge weights using retrieval temporal order.
+  // Runs after Hebbian strengthening (step 6) so it builds on existing edges.
+  try {
+    const { applyStdpPlasticity } = await import('./brain-stdp.js');
+    const stdpResult = await applyStdpPlasticity(projectRoot);
+    result.stdpPlasticity = stdpResult;
+  } catch (err) {
+    console.warn('[consolidation] Step 9 STDP plasticity failed:', err);
+  }
+
   return result;
 }
 
@@ -979,9 +998,9 @@ async function strengthenCoRetrievedEdges(projectRoot: string): Promise<number>
       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) {
@@ -990,9 +1009,9 @@ async function strengthenCoRetrievedEdges(projectRoot: string): Promise<number>
           .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', ?)
+            VALUES (?, ?, ?, 0.3, 'consolidation:co-retrieval', ?)
           `)
-          .run(nodeFrom, nodeTo, now);
+          .run(nodeFrom, nodeTo, EDGE_TYPES.CO_RETRIEVED, now);
       }
       strengthened++;
     } catch {