@cogmem/engram 0.3.0 → 0.3.1

package/src/cli/commands/health.ts

@@ -1,7 +1,8 @@
 import { defineCommand } from "citty";
+
 import { EngramEngine } from "../../core/engine.ts";
-import { focusUtilization } from "../../core/working-memory.ts";
 import { refreshActivations } from "../../core/forgetting.ts";
+import { focusUtilization } from "../../core/working-memory.ts";
 import { bold, dim, green, yellow, red, isInteractive } from "../format.ts";
 
 export const healthCommand = defineCommand({
@@ -13,7 +14,10 @@ export const healthCommand = defineCommand({
     const engine = EngramEngine.create();
     try {
       const { atRisk } = refreshActivations(engine.storage, engine.config);
-      const { used, capacity } = focusUtilization(engine.storage, engine.config);
+      const { used, capacity } = focusUtilization(
+        engine.storage,
+        engine.config
+      );
       const lastConsolidation = engine.storage.getLastConsolidation();
       const totalMemories = engine.storage.getMemoryCount();
       const associationCount = engine.storage.getAssociationCount();
@@ -29,7 +33,7 @@ export const healthCommand = defineCommand({
             totalMemories,
             associations: associationCount,
             lastConsolidationHoursAgo: hoursAgo ? Math.round(hoursAgo) : null,
-          }),
+          })
         );
         return;
       }
@@ -37,42 +41,72 @@ export const healthCommand = defineCommand({
       console.log(bold("  engram — health check\n"));
 
       if (atRisk > 0) {
-        console.log(yellow(`  ! ${atRisk} memories at risk of being forgotten`));
+        console.log(
+          yellow(`  ! ${atRisk} memories at risk of being forgotten`)
+        );
       } else {
         console.log(green("  + All memories above retrieval threshold"));
       }
 
       if (used <= capacity) {
-        console.log(green(`  + Working memory within capacity (${used}/${capacity})`));
+        console.log(
+          green(`  + Working memory within capacity (${used}/${capacity})`)
+        );
       } else {
-        console.log(red(`  ! Working memory over capacity (${used}/${capacity})`));
+        console.log(
+          red(`  ! Working memory over capacity (${used}/${capacity})`)
+        );
       }
 
       if (lastConsolidation) {
         const hoursAgo = (Date.now() - lastConsolidation.ranAt) / 3600000;
         if (hoursAgo > 18) {
-          console.log(red(`  ! Consolidation overdue (last: ${Math.round(hoursAgo)}h ago)`));
+          console.log(
+            red(
+              `  ! Consolidation overdue (last: ${Math.round(hoursAgo)}h ago)`
+            )
+          );
         } else if (hoursAgo > 8) {
           console.log(
-            yellow(`  ~ Consolidation recommended soon (last: ${Math.round(hoursAgo)}h ago)`),
+            yellow(
+              `  ~ Consolidation recommended soon (last: ${Math.round(
+                hoursAgo
+              )}h ago)`
+            )
           );
         } else {
-          console.log(green(`  + Consolidation recent (last: ${Math.round(hoursAgo)}h ago)`));
+          console.log(
+            green(
+              `  + Consolidation recent (last: ${Math.round(hoursAgo)}h ago)`
+            )
+          );
         }
       } else if (totalMemories > 0) {
-        console.log(yellow("  ! No consolidation has ever run — run `engram sleep`"));
+        console.log(
+          yellow("  ! No consolidation has ever run — run `engram sleep`")
+        );
       } else {
         console.log(dim("  ~ No memories encoded yet"));
       }
 
       if (totalMemories > 5 && associationCount === 0) {
-        console.log(yellow("  ! No associations formed — run `engram sleep` to discover links"));
+        console.log(
+          yellow(
+            "  ! No associations formed — run `engram sleep` to discover links"
+          )
+        );
       } else if (associationCount > 0) {
         const ratio = associationCount / Math.max(1, totalMemories);
         if (ratio > 1) {
-          console.log(green(`  + Association network is rich (${associationCount} links)`));
+          console.log(
+            green(`  + Association network is rich (${associationCount} links)`)
+          );
         } else {
-          console.log(green(`  + Association network is healthy (${associationCount} links)`));
+          console.log(
+            green(
+              `  + Association network is healthy (${associationCount} links)`
+            )
+          );
         }
       }
     } finally {

package/src/cli/commands/inspect.ts

@@ -1,4 +1,5 @@
 import { defineCommand } from "citty";
+
 import { EngramEngine } from "../../core/engine.ts";
 import { formatMemoryInspection, dim } from "../format.ts";
 
@@ -18,7 +19,9 @@ export const inspectCommand = defineCommand({
     const engine = EngramEngine.create();
     try {
       const allMemories = engine.storage.getAllMemories();
-      const match = allMemories.find((m) => m.id === args.id || m.id.startsWith(args.id));
+      const match = allMemories.find(
+        (m) => m.id === args.id || m.id.startsWith(args.id)
+      );
 
       if (!match) {
         console.log(dim(`  No memory found matching "${args.id}"`));
@@ -28,7 +31,9 @@ export const inspectCommand = defineCommand({
       const accessLog = engine.storage.getAccessLog(match.id);
       const associations = engine.storage.getAssociations(match.id);
 
-      console.log(formatMemoryInspection(match, accessLog.length, associations.length));
+      console.log(
+        formatMemoryInspection(match, accessLog.length, associations.length)
+      );
     } finally {
       engine.close();
     }

package/src/cli/commands/install.ts

@@ -1,10 +1,12 @@
-import { defineCommand } from "citty";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+
+import { defineCommand } from "citty";
 import { consola } from "consola";
-import { getProvider, availableProviders } from "../providers/index.ts";
+
 import { green, dim, yellow, bold } from "../format.ts";
+import { getProvider, availableProviders } from "../providers/index.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SKILL_PATH = join(__dirname, "..", "..", "..", "SKILL.md");
@@ -96,16 +98,23 @@ export const installCommand = defineCommand({
     if (result.status === "already_installed") {
       console.log(dim("  already installed — nothing to do"));
       console.log(dim(`  skill: ${result.skillPath}`));
-      if (result.mcpConfigPath) console.log(dim(`  mcp:   ${result.mcpConfigPath}`));
+      if (result.mcpConfigPath)
+        console.log(dim(`  mcp:   ${result.mcpConfigPath}`));
       return;
     }
 
     const prefix = dryRun ? "would install" : "installed";
     const check = dryRun ? yellow("~") : green("\u2713");
 
-    console.log(`  ${check} Skill ${prefix} ${dim("\u2192")} ${bold(result.skillPath)}`);
+    console.log(
+      `  ${check} Skill ${prefix} ${dim("\u2192")} ${bold(result.skillPath)}`
+    );
     if (result.mcpConfigured && result.mcpConfigPath) {
-      console.log(`  ${check} MCP ${prefix}   ${dim("\u2192")} ${bold(result.mcpConfigPath)}`);
+      console.log(
+        `  ${check} MCP ${prefix}   ${dim("\u2192")} ${bold(
+          result.mcpConfigPath
+        )}`
+      );
     } else if (result.mcpConfigPath) {
       console.log(dim(`  - MCP already configured → ${result.mcpConfigPath}`));
     }

package/src/cli/commands/list.ts

@@ -1,4 +1,5 @@
 import { defineCommand } from "citty";
+
 import { EngramEngine } from "../../core/engine.ts";
 import { isValidMemoryType } from "../../core/memory.ts";
 import { formatMemoryList } from "../format.ts";
@@ -32,7 +33,8 @@ export const listCommand = defineCommand({
   run({ args }) {
     const engine = EngramEngine.create();
     try {
-      const type = args.type && isValidMemoryType(args.type) ? args.type : undefined;
+      const type =
+        args.type && isValidMemoryType(args.type) ? args.type : undefined;
       const limit = Number(args.limit);
 
       let memories;

package/src/cli/commands/recall.ts

@@ -1,8 +1,9 @@
 import { defineCommand } from "citty";
+
 import { EngramEngine } from "../../core/engine.ts";
+import { isValidMemoryType } from "../../core/memory.ts";
 import { recall } from "../../core/recall.ts";
 import { formatRecallResults } from "../format.ts";
-import { isValidMemoryType } from "../../core/memory.ts";
 
 export const recallCommand = defineCommand({
   meta: {
@@ -38,7 +39,8 @@ export const recallCommand = defineCommand({
   run({ args }) {
     const engine = EngramEngine.create();
     try {
-      const typeFilter = args.type && isValidMemoryType(args.type) ? args.type : undefined;
+      const typeFilter =
+        args.type && isValidMemoryType(args.type) ? args.type : undefined;
 
       const results = recall(engine.storage, args.cue, engine.config, {
         type: typeFilter,

package/src/cli/commands/sleep.ts

@@ -1,13 +1,15 @@
 import { defineCommand } from "citty";
-import { EngramEngine } from "../../core/engine.ts";
-import { consolidate } from "../../core/consolidation.ts";
+
 import { discoverChunks } from "../../core/chunking.ts";
+import { consolidate } from "../../core/consolidation.ts";
+import { EngramEngine } from "../../core/engine.ts";
 import { bold, dim, green, cyan, isInteractive } from "../format.ts";
 
 export const sleepCommand = defineCommand({
   meta: {
     name: "sleep",
-    description: "Run consolidation cycle (replay, strengthen, prune, extract, link)",
+    description:
+      "Run consolidation cycle (replay, strengthen, prune, extract, link)",
   },
   args: {
     report: {
@@ -41,7 +43,7 @@ export const sleepCommand = defineCommand({
                   })),
                 }
               : {}),
-          }),
+          })
         );
         return;
       }
@@ -49,17 +51,29 @@ export const sleepCommand = defineCommand({
       console.log(dim("  Running consolidation cycle...\n"));
       console.log(green("  Consolidation complete:\n"));
       console.log(
-        `  ${cyan("Strengthened")} ${result.memoriesStrengthened} frequently-accessed memories`,
+        `  ${cyan("Strengthened")} ${
+          result.memoriesStrengthened
+        } frequently-accessed memories`
       );
       console.log(
-        `  ${cyan("Pruned")}       ${result.memoriesPruned} memories below activation threshold`,
+        `  ${cyan("Pruned")}       ${
+          result.memoriesPruned
+        } memories below activation threshold`
       );
       console.log(
-        `  ${cyan("Extracted")}    ${result.factsExtracted} semantic facts from episodic patterns`,
+        `  ${cyan("Extracted")}    ${
+          result.factsExtracted
+        } semantic facts from episodic patterns`
+      );
+      console.log(
+        `  ${cyan("Discovered")}   ${
+          result.associationsDiscovered
+        } new associations`
       );
-      console.log(`  ${cyan("Discovered")}   ${result.associationsDiscovered} new associations`);
       if (chunks.length > 0) {
-        console.log(`  ${cyan("Chunked")}      ${chunks.length} new memory groups`);
+        console.log(
+          `  ${cyan("Chunked")}      ${chunks.length} new memory groups`
+        );
       }
 
       if (args.report) {
@@ -84,14 +98,20 @@ export const sleepCommand = defineCommand({
         if (chunks.length > 0) {
           console.log(bold("  New Chunks:"));
           for (const chunk of chunks) {
-            console.log(`    ${dim(">")} ${chunk.label} (${chunk.memberIds.length} memories)`);
+            console.log(
+              `    ${dim(">")} ${chunk.label} (${
+                chunk.memberIds.length
+              } memories)`
+            );
           }
           console.log("");
         }
 
         if (result.discoveredAssociationPairs.length > 0) {
           console.log(
-            bold(`  Associations Discovered: ${result.discoveredAssociationPairs.length}`),
+            bold(
+              `  Associations Discovered: ${result.discoveredAssociationPairs.length}`
+            )
           );
         }
       }

package/src/cli/commands/stats.ts

@@ -1,8 +1,9 @@
 import { defineCommand } from "citty";
+
 import { EngramEngine } from "../../core/engine.ts";
+import { refreshActivations } from "../../core/forgetting.ts";
 import { focusUtilization } from "../../core/working-memory.ts";
 import { bold, dim, green, yellow, red, isInteractive } from "../format.ts";
-import { refreshActivations } from "../../core/forgetting.ts";
 
 export const statsCommand = defineCommand({
   meta: {
@@ -18,16 +19,28 @@ export const statsCommand = defineCommand({
       const semanticCount = engine.storage.getMemoryCount("semantic");
       const proceduralCount = engine.storage.getMemoryCount("procedural");
       const associationCount = engine.storage.getAssociationCount();
-      const { used, capacity } = focusUtilization(engine.storage, engine.config);
+      const { used, capacity } = focusUtilization(
+        engine.storage,
+        engine.config
+      );
 
       const lastConsolidation = engine.storage.getLastConsolidation();
 
       const projectContext = engine.projectContext;
       const projectCounts = projectContext
         ? {
-            episodic: engine.storage.getMemoryCountByContext(projectContext, "episodic"),
-            semantic: engine.storage.getMemoryCountByContext(projectContext, "semantic"),
-            procedural: engine.storage.getMemoryCountByContext(projectContext, "procedural"),
+            episodic: engine.storage.getMemoryCountByContext(
+              projectContext,
+              "episodic"
+            ),
+            semantic: engine.storage.getMemoryCountByContext(
+              projectContext,
+              "semantic"
+            ),
+            procedural: engine.storage.getMemoryCountByContext(
+              projectContext,
+              "procedural"
+            ),
             total: engine.storage.getMemoryCountByContext(projectContext),
           }
         : null;
@@ -41,9 +54,13 @@ export const statsCommand = defineCommand({
             procedural: proceduralCount,
             associations: associationCount,
             atRisk,
-            lastConsolidation: lastConsolidation ? { ranAt: lastConsolidation.ranAt } : null,
-            ...(projectCounts ? { project: { context: projectContext, ...projectCounts } } : {}),
-          }),
+            lastConsolidation: lastConsolidation
+              ? { ranAt: lastConsolidation.ranAt }
+              : null,
+            ...(projectCounts
+              ? { project: { context: projectContext, ...projectCounts } }
+              : {}),
+          })
         );
         return;
       }
@@ -54,27 +71,33 @@ export const statsCommand = defineCommand({
         used >= capacity
           ? red(`${used}/${capacity} slots used (FULL)`)
           : used > capacity * 0.7
-            ? yellow(`${used}/${capacity} slots used`)
-            : green(`${used}/${capacity} slots used`);
+          ? yellow(`${used}/${capacity} slots used`)
+          : green(`${used}/${capacity} slots used`);
       console.log(`  Working Memory:  ${wmStatus}`);
 
       console.log(
         `  Episodic:        ${episodicCount} memories` +
-          (atRisk > 0 ? ` ${yellow(`(${atRisk} at risk of forgetting)`)}` : ""),
+          (atRisk > 0 ? ` ${yellow(`(${atRisk} at risk of forgetting)`)}` : "")
       );
       console.log(`  Semantic:        ${semanticCount} facts`);
-      console.log(`  Procedural:      ${proceduralCount} skills ${dim("(immune to decay)")}`);
+      console.log(
+        `  Procedural:      ${proceduralCount} skills ${dim(
+          "(immune to decay)"
+        )}`
+      );
 
       console.log(`  Associations:    ${associationCount} links`);
 
       if (lastConsolidation) {
-        const hoursAgo = Math.round((Date.now() - lastConsolidation.ranAt) / 3600000);
+        const hoursAgo = Math.round(
+          (Date.now() - lastConsolidation.ranAt) / 3600000
+        );
         const consolidationStatus =
           hoursAgo > 12
             ? red(`${hoursAgo}h ago (overdue)`)
             : hoursAgo > 6
-              ? yellow(`${hoursAgo}h ago`)
-              : green(`${hoursAgo}h ago`);
+            ? yellow(`${hoursAgo}h ago`)
+            : green(`${hoursAgo}h ago`);
         console.log(`  Last sleep:      ${consolidationStatus}`);
       } else {
         console.log(`  Last sleep:      ${dim("never")}`);

package/src/cli/format.ts

@@ -1,8 +1,9 @@
-import type { Memory, RecallResult } from "../core/memory.ts";
-import kleur from "kleur";
 import Table from "cli-table3";
 import dayjs from "dayjs";
 import relativeTime from "dayjs/plugin/relativeTime.js";
+import kleur from "kleur";
+
+import type { Memory, RecallResult } from "../core/memory.ts";
 
 dayjs.extend(relativeTime);
 

package/src/cli/index.ts

@@ -1,15 +1,16 @@
 #!/usr/bin/env bun
 import { defineCommand, runMain } from "citty";
+
 import pkg from "../../package.json";
 import { encodeCommand } from "./commands/encode.ts";
-import { recallCommand } from "./commands/recall.ts";
 import { focusCommand } from "./commands/focus.ts";
+import { healthCommand } from "./commands/health.ts";
 import { inspectCommand } from "./commands/inspect.ts";
-import { statsCommand } from "./commands/stats.ts";
+import { installCommand } from "./commands/install.ts";
 import { listCommand } from "./commands/list.ts";
+import { recallCommand } from "./commands/recall.ts";
 import { sleepCommand } from "./commands/sleep.ts";
-import { healthCommand } from "./commands/health.ts";
-import { installCommand } from "./commands/install.ts";
+import { statsCommand } from "./commands/stats.ts";
 
 const main = defineCommand({
   meta: {

package/src/cli/providers/claude.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
 import { homedir } from "node:os";
+import { join } from "node:path";
+
 import type { ProviderInstaller } from "./types.ts";
 
 const MCP_SERVER_CONFIG = {
@@ -55,12 +56,17 @@ export const claudeProvider: ProviderInstaller = {
   async installGlobal(skillContent, dryRun) {
     const home = homedir();
     const skillDir = join(home, ".claude", "skills", "engram");
-    const configPath = join(home, ".claude", "settings.json");
+    const configPath = join(home, ".claude.json");
 
     const skillInstalled = installSkill(skillDir, skillContent, dryRun);
     const mcpInstalled = configureMcp(configPath, dryRun);
 
-    const status = !skillInstalled && !mcpInstalled ? "already_installed" : skillInstalled && mcpInstalled ? "installed" : "updated";
+    const status =
+      !skillInstalled && !mcpInstalled
+        ? "already_installed"
+        : skillInstalled && mcpInstalled
+          ? "installed"
+          : "updated";
 
     return {
       status,
@@ -72,12 +78,17 @@ export const claudeProvider: ProviderInstaller = {
 
   async installProject(skillContent, projectDir, dryRun) {
     const skillDir = join(projectDir, ".claude", "skills", "engram");
-    const configPath = join(projectDir, ".claude", "settings.local.json");
+    const configPath = join(projectDir, ".mcp.json");
 
     const skillInstalled = installSkill(skillDir, skillContent, dryRun);
     const mcpInstalled = configureMcp(configPath, dryRun);
 
-    const status = !skillInstalled && !mcpInstalled ? "already_installed" : skillInstalled && mcpInstalled ? "installed" : "updated";
+    const status =
+      !skillInstalled && !mcpInstalled
+        ? "already_installed"
+        : skillInstalled && mcpInstalled
+          ? "installed"
+          : "updated";
 
     return {
       status,

package/src/cli/providers/types.ts

@@ -12,5 +12,9 @@ export interface ProviderInstaller {
   displayName: string;
   available: boolean;
   installGlobal(skillContent: string, dryRun: boolean): Promise<InstallResult>;
-  installProject(skillContent: string, projectDir: string, dryRun: boolean): Promise<InstallResult>;
+  installProject(
+    skillContent: string,
+    projectDir: string,
+    dryRun: boolean
+  ): Promise<InstallResult>;
 }

package/src/config/defaults.ts

@@ -50,11 +50,14 @@ export function resolveDbPath(dbPath: string): string {
   return dbPath;
 }
 
-export function loadConfig(overrides?: Partial<CognitiveConfig>): CognitiveConfig {
+export function loadConfig(
+  overrides?: Partial<CognitiveConfig>
+): CognitiveConfig {
   const config = { ...DEFAULT_CONFIG, ...overrides };
 
   if (process.env.ENGRAM_DB_PATH) config.dbPath = process.env.ENGRAM_DB_PATH;
-  if (process.env.ENGRAM_DECAY_RATE) config.decayRate = Number(process.env.ENGRAM_DECAY_RATE);
+  if (process.env.ENGRAM_DECAY_RATE)
+    config.decayRate = Number(process.env.ENGRAM_DECAY_RATE);
   if (process.env.ENGRAM_WM_CAPACITY)
     config.workingMemoryCapacity = Number(process.env.ENGRAM_WM_CAPACITY);
   if (process.env.ENGRAM_RETRIEVAL_THRESHOLD)

package/src/core/activation.ts

@@ -4,7 +4,7 @@ import type { CognitiveConfig } from "../config/defaults.ts";
 export function baseLevelActivation(
   accessTimestamps: number[],
   now: number,
-  decayRate: number,
+  decayRate: number
 ): number {
   if (accessTimestamps.length === 0) return -Infinity;
 
@@ -18,13 +18,20 @@ export function baseLevelActivation(
 }
 
 // S_ji = S - ln(fan_j)
-export function spreadingActivationStrength(maxStrength: number, fanCount: number): number {
+export function spreadingActivationStrength(
+  maxStrength: number,
+  fanCount: number
+): number {
   if (fanCount <= 0) return 0;
   return Math.max(0, maxStrength - Math.log(fanCount));
 }
 
 // A_i = B_i + Σ(W_j · S_ji) + ε
-export function totalActivation(baseLevel: number, spreadingSum: number, noise: number): number {
+export function totalActivation(
+  baseLevel: number,
+  spreadingSum: number,
+  noise: number
+): number {
   return baseLevel + spreadingSum + noise;
 }
 
@@ -44,7 +51,7 @@ export function canRetrieve(activation: number, threshold: number): boolean {
 export function retrievalLatency(
   activation: number,
   latencyFactor: number,
-  latencyExponent: number,
+  latencyExponent: number
 ): number {
   return latencyFactor * Math.exp(-latencyExponent * activation);
 }
@@ -57,19 +64,44 @@ export function computeActivation(
     spreadingSum?: number;
     noiseOverride?: number;
     emotionWeight?: number;
-  },
-): { activation: number; baseLevel: number; spreading: number; noise: number; latency: number } {
-  const baseLevel = baseLevelActivation(accessTimestamps, now, config.decayRate);
+  }
+): {
+  activation: number;
+  baseLevel: number;
+  spreading: number;
+  noise: number;
+  latency: number;
+} {
+  const baseLevel = baseLevelActivation(
+    accessTimestamps,
+    now,
+    config.decayRate
+  );
 
   const emotionBoost = options?.emotionWeight
     ? Math.log(1 + options.emotionWeight * config.emotionalBoostFactor)
     : 0;
 
   const spreading = options?.spreadingSum ?? 0;
-  const noise = options?.noiseOverride ?? activationNoise(config.activationNoise);
+  const noise =
+    options?.noiseOverride ?? activationNoise(config.activationNoise);
 
-  const activation = totalActivation(baseLevel + emotionBoost, spreading, noise);
-  const latency = retrievalLatency(activation, config.latencyFactor, config.latencyExponent);
+  const activation = totalActivation(
+    baseLevel + emotionBoost,
+    spreading,
+    noise
+  );
+  const latency = retrievalLatency(
+    activation,
+    config.latencyFactor,
+    config.latencyExponent
+  );
 
-  return { activation, baseLevel: baseLevel + emotionBoost, spreading, noise, latency };
+  return {
+    activation,
+    baseLevel: baseLevel + emotionBoost,
+    spreading,
+    noise,
+    latency,
+  };
 }

package/src/core/associations.ts

@@ -122,10 +122,7 @@ export function formSemanticAssociations(
   const candidates = preloadedMemories ?? storage.getAllMemories();
   const existing = storage.getAssociations(memory.id);
   const linkedSet = new Set(
-    existing.flatMap((a) => [
-      `${a.sourceId}:${a.targetId}`,
-      `${a.targetId}:${a.sourceId}`,
-    ]),
+    existing.flatMap((a) => [`${a.sourceId}:${a.targetId}`, `${a.targetId}:${a.sourceId}`]),
   );
   const formed: Association[] = [];
 

package/src/core/chunking.ts

@@ -62,7 +62,10 @@ class UnionFind {
   }
 }
 
-export function discoverChunks(storage: EngramStorage, config: CognitiveConfig): Chunk[] {
+export function discoverChunks(
+  storage: EngramStorage,
+  config: CognitiveConfig
+): Chunk[] {
   const allMemories = storage.getAllMemories();
   const memoryMap = new Map<string, Memory>();
   const uf = new UnionFind();
@@ -77,7 +80,8 @@ export function discoverChunks(storage: EngramStorage, config: CognitiveConfig):
     const associations = storage.getAssociations(memory.id);
     for (const assoc of associations) {
       if (assoc.strength < config.chunkingSimilarityThreshold) continue;
-      const otherId = assoc.sourceId === memory.id ? assoc.targetId : assoc.sourceId;
+      const otherId =
+        assoc.sourceId === memory.id ? assoc.targetId : assoc.sourceId;
       if (!memoryMap.has(otherId)) continue;
       uf.union(memory.id, otherId);
     }
@@ -89,7 +93,10 @@ export function discoverChunks(storage: EngramStorage, config: CognitiveConfig):
 
     const members = memberIds.map((id) => memoryMap.get(id)!);
     const chunkId = generateId();
-    const keywords = extractKeywords(members.map((m) => m.content).join(" "), 3);
+    const keywords = extractKeywords(
+      members.map((m) => m.content).join(" "),
+      3
+    );
     const label = keywords.join(" + ") || "chunk";
 
     for (const member of members) {
@@ -103,6 +110,9 @@ export function discoverChunks(storage: EngramStorage, config: CognitiveConfig):
   return chunks;
 }
 
-export function getChunkMembers(storage: EngramStorage, chunkId: string): Memory[] {
+export function getChunkMembers(
+  storage: EngramStorage,
+  chunkId: string
+): Memory[] {
   return storage.getAllMemories().filter((m) => m.chunkId === chunkId);
 }