@learningnodes/elen 0.1.1

package/dist/storage/sqlite.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteStorage = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class SQLiteStorage {
+    constructor(path, projectId = 'default') {
+        this.db = new better_sqlite3_1.default(path);
+        this.projectId = projectId;
+        this.init();
+    }
+    init() {
+        const pragmaQuery = this.db.prepare('PRAGMA user_version').get();
+        const versionRow = pragmaQuery ? pragmaQuery.user_version : 0;
+        if (versionRow === 0) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS constraint_sets (
+          constraint_set_id TEXT PRIMARY KEY,
+          atoms TEXT NOT NULL,
+          summary TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        );
+  
+        CREATE TABLE IF NOT EXISTS records (
+          record_id TEXT PRIMARY KEY,
+          decision_id TEXT NOT NULL,
+          q_id TEXT NOT NULL,
+          agent_id TEXT NOT NULL,
+          domain TEXT NOT NULL,
+          project_id TEXT NOT NULL DEFAULT 'default',
+          decision_text TEXT NOT NULL,
+          constraint_set_id TEXT NOT NULL,
+          refs TEXT NOT NULL,
+          status TEXT NOT NULL,
+          supersedes_id TEXT,
+          timestamp TEXT NOT NULL,
+          record_json TEXT NOT NULL,
+          FOREIGN KEY(constraint_set_id) REFERENCES constraint_sets(constraint_set_id)
+        );
+  
+        CREATE TABLE IF NOT EXISTS projects (
+          project_id TEXT PRIMARY KEY,
+          display_name TEXT NOT NULL,
+          source_hint TEXT,
+          created_at TEXT NOT NULL
+        );
+  
+        CREATE TABLE IF NOT EXISTS project_sharing (
+          source_project_id TEXT NOT NULL,
+          target_project_id TEXT NOT NULL,
+          direction TEXT NOT NULL DEFAULT 'one-way',
+          enabled INTEGER NOT NULL DEFAULT 1,
+          PRIMARY KEY (source_project_id, target_project_id)
+        );
+  
+          CREATE TABLE IF NOT EXISTS search_log (
+            search_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            query TEXT NOT NULL,
+            domain TEXT,
+            project_id TEXT NOT NULL,
+            hits INTEGER NOT NULL DEFAULT 0,
+            cross_project_hits INTEGER NOT NULL DEFAULT 0,
+            searched_at TEXT NOT NULL
+          );
+        `);
+        }
+        else {
+            // Legacy migration: Database exists but lacks the v1 schema columns.
+            this.db.exec("BEGIN TRANSACTION;");
+            try {
+                this.db.exec(`
+            CREATE TABLE IF NOT EXISTS constraint_sets (
+              constraint_set_id TEXT PRIMARY KEY,
+              atoms TEXT NOT NULL,
+              summary TEXT NOT NULL,
+              created_at TEXT NOT NULL
+            );
+          `);
+                // Alter legacy records table to inject the new columns gracefully
+                const queries = [
+                    "ALTER TABLE records ADD COLUMN q_id TEXT NOT NULL DEFAULT 'legacy_q'",
+                    "ALTER TABLE records ADD COLUMN constraint_set_id TEXT NOT NULL DEFAULT 'legacy_c'",
+                    "ALTER TABLE records ADD COLUMN refs TEXT NOT NULL DEFAULT '[]'",
+                    "ALTER TABLE records ADD COLUMN status TEXT NOT NULL DEFAULT 'active'",
+                    "ALTER TABLE records ADD COLUMN supersedes_id TEXT",
+                    "ALTER TABLE records ADD COLUMN timestamp TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+                    "ALTER TABLE records ADD COLUMN decision_text TEXT NOT NULL DEFAULT ''"
+                ];
+                for (const query of queries) {
+                    try {
+                        this.db.exec(query);
+                    }
+                    catch (e) {
+                        // Ignore "duplicate column name" if partially migrated
+                    }
+                }
+                // Migrate existing 'answer' data over to 'decision_text' if applicable
+                try {
+                    this.db.exec("UPDATE records SET decision_text = answer WHERE decision_text = '' AND answer IS NOT NULL");
+                }
+                catch (e) {
+                    // 'answer' column might have been dropped or didn't exist
+                }
+                this.db.exec("COMMIT;");
+            }
+            catch (e) {
+                this.db.exec("ROLLBACK;");
+                throw e;
+            }
+        }
+        this.db.exec('PRAGMA user_version = 1');
+        // Ensure current project exists in projects table
+        this.ensureProject(this.projectId);
+    }
+    ensureProject(projectId, displayName) {
+        const existing = this.db
+            .prepare('SELECT project_id FROM projects WHERE project_id = ?')
+            .get(projectId);
+        if (!existing) {
+            this.db.prepare(`
+        INSERT INTO projects (project_id, display_name, source_hint, created_at)
+        VALUES (@project_id, @display_name, @source_hint, @created_at)
+      `).run({
+                project_id: projectId,
+                display_name: displayName || projectId.replace(/[-_]/g, ' ').replace(/\\b\\w/g, c => c.toUpperCase()),
+                source_hint: null,
+                created_at: new Date().toISOString()
+            });
+        }
+    }
+    // --- Project & Sharing Management ---
+    getProjects() {
+        return this.db.prepare('SELECT * FROM projects ORDER BY created_at ASC').all();
+    }
+    getSharing() {
+        return this.db.prepare('SELECT * FROM project_sharing ORDER BY source_project_id').all();
+    }
+    upsertSharing(source, target, direction, enabled) {
+        this.db.prepare(`
+      INSERT INTO project_sharing (source_project_id, target_project_id, direction, enabled)
+      VALUES (@source, @target, @direction, @enabled)
+      ON CONFLICT(source_project_id, target_project_id)
+      DO UPDATE SET direction = @direction, enabled = @enabled
+    `).run({ source, target, direction: direction, enabled: enabled ? 1 : 0 });
+    }
+    deleteSharing(source, target) {
+        this.db.prepare('DELETE FROM project_sharing WHERE source_project_id = ? AND target_project_id = ?')
+            .run([source, target]);
+    }
+    getAccessibleProjects() {
+        const hasRules = this.db.prepare(`
+      SELECT 1 FROM project_sharing
+      WHERE source_project_id = ? OR target_project_id = ?
+      LIMIT 1
+    `).get(this.projectId, this.projectId);
+        if (!hasRules) {
+            const all = this.db.prepare('SELECT project_id FROM projects').all();
+            const ids = new Set(all.map(r => r.project_id));
+            ids.add(this.projectId);
+            return [...ids];
+        }
+        const accessible = new Set([this.projectId]);
+        const inbound = this.db.prepare(`
+      SELECT source_project_id FROM project_sharing
+      WHERE target_project_id = ? AND enabled = 1
+    `).all(this.projectId);
+        for (const row of inbound) {
+            accessible.add(row.source_project_id);
+        }
+        const bidir = this.db.prepare(`
+      SELECT source_project_id, target_project_id FROM project_sharing
+      WHERE direction = 'bi-directional' AND enabled = 1
+        AND (source_project_id = ? OR target_project_id = ?)
+    `).all([this.projectId, this.projectId]);
+        for (const row of bidir) {
+            accessible.add(row.source_project_id);
+            accessible.add(row.target_project_id);
+        }
+        return [...accessible];
+    }
+    // --- Core Storage Methods ---
+    async saveConstraintSet(constraintSet) {
+        const statement = this.db.prepare(`
+      INSERT OR IGNORE INTO constraint_sets (constraint_set_id, atoms, summary, created_at)
+      VALUES (@constraint_set_id, @atoms, @summary, @created_at)
+    `);
+        statement.run({
+            constraint_set_id: constraintSet.constraint_set_id,
+            atoms: JSON.stringify(constraintSet.atoms),
+            summary: constraintSet.summary,
+            created_at: new Date().toISOString()
+        });
+    }
+    async getConstraintSet(id) {
+        const row = this.db
+            .prepare('SELECT constraint_set_id, atoms, summary FROM constraint_sets WHERE constraint_set_id = ?')
+            .get(id);
+        if (!row) {
+            return null;
+        }
+        return {
+            constraint_set_id: row.constraint_set_id,
+            atoms: JSON.parse(row.atoms),
+            summary: row.summary
+        };
+    }
+    async saveRecord(record) {
+        const statement = this.db.prepare(`
+      INSERT OR REPLACE INTO records (
+        record_id, decision_id, q_id, agent_id, domain, project_id, decision_text, 
+        constraint_set_id, refs, status, supersedes_id, timestamp, record_json
+      )
+      VALUES (
+        @record_id, @decision_id, @q_id, @agent_id, @domain, @project_id, @decision_text, 
+        @constraint_set_id, @refs, @status, @supersedes_id, @timestamp, @record_json
+      )
+    `);
+        const enrichedRecord = { ...record, project_id: this.projectId };
+        statement.run({
+            record_id: record.decision_id,
+            decision_id: record.decision_id,
+            q_id: record.q_id,
+            agent_id: record.agent_id,
+            domain: record.domain,
+            project_id: this.projectId,
+            decision_text: record.decision_text,
+            constraint_set_id: record.constraint_set_id,
+            refs: JSON.stringify(record.refs),
+            status: record.status,
+            supersedes_id: record.supersedes_id ?? null,
+            timestamp: record.timestamp,
+            record_json: JSON.stringify(enrichedRecord)
+        });
+    }
+    async getRecord(recordId) {
+        const row = this.db
+            .prepare('SELECT record_json FROM records WHERE decision_id = ?')
+            .get(recordId);
+        if (!row) {
+            return null;
+        }
+        return JSON.parse(row.record_json);
+    }
+    async searchRecords(opts) {
+        const conditions = [];
+        const params = {};
+        if (opts.includeShared !== false) {
+            const accessible = this.getAccessibleProjects();
+            const placeholders = accessible.map((_, i) => `@proj${i}`);
+            conditions.push(`records.project_id IN (${placeholders.join(', ')})`);
+            accessible.forEach((id, i) => { params[`proj${i}`] = id; });
+        }
+        else {
+            const projId = opts.projectId || this.projectId;
+            conditions.push('records.project_id = @projectId');
+            params.projectId = projId;
+        }
+        if (opts.domain) {
+            conditions.push('records.domain = @domain');
+            params.domain = opts.domain;
+        }
+        if (opts.query) {
+            conditions.push(`(
+        LOWER(records.decision_text) LIKE @query OR
+        LOWER(records.domain) LIKE @query OR
+        LOWER(records.q_id) LIKE @query
+      )`);
+            params.query = `%${opts.query.toLowerCase()}%`;
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limitClause = opts.limit ? `LIMIT ${Math.max(1, opts.limit)}` : '';
+        const rows = this.db
+            .prepare(`SELECT records.record_json FROM records
+         ${whereClause}
+         ORDER BY records.timestamp DESC
+         ${limitClause}`)
+            .all(params);
+        const results = rows.map((row) => JSON.parse(row.record_json));
+        try {
+            const crossProjectHits = results.filter((r) => {
+                return r.project_id && r.project_id !== this.projectId;
+            }).length;
+            this.db.prepare(`
+        INSERT INTO search_log(query, domain, project_id, hits, cross_project_hits, searched_at)
+        VALUES(@query, @domain, @project_id, @hits, @cross_project_hits, @searched_at)
+      `).run({
+                query: opts.query || '',
+                domain: opts.domain || null,
+                project_id: this.projectId,
+                hits: results.length,
+                cross_project_hits: crossProjectHits,
+                searched_at: new Date().toISOString()
+            });
+        }
+        catch {
+            // Non-critical: don't fail search if logging fails
+        }
+        return results;
+    }
+    async getAgentDecisions(agentId, domain) {
+        const statement = domain
+            ? this.db.prepare('SELECT record_json FROM records WHERE agent_id = @agentId AND domain = @domain ORDER BY timestamp DESC')
+            : this.db.prepare('SELECT record_json FROM records WHERE agent_id = @agentId ORDER BY timestamp DESC');
+        const rows = statement.all({ agentId, domain });
+        return rows.map((row) => JSON.parse(row.record_json));
+    }
+    async getCompetencyProfile(agentId) {
+        const records = await this.getAgentDecisions(agentId);
+        const domainCounts = new Map();
+        for (const record of records) {
+            const count = domainCounts.get(record.domain) ?? 0;
+            domainCounts.set(record.domain, count + 1);
+        }
+        const domains = Array.from(domainCounts.keys());
+        const strengths = [];
+        const weaknesses = [];
+        // Simply map domain frequency to strengths
+        for (const [domain, count] of domainCounts.entries()) {
+            if (count >= 5) {
+                strengths.push(domain);
+            }
+        }
+        return {
+            agent_id: agentId,
+            domains,
+            strengths,
+            weaknesses,
+            updated_at: new Date().toISOString()
+        };
+    }
+}
+exports.SQLiteStorage = SQLiteStorage;

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+import type { CompetencyProfile, DecisionRecord, DecisionStatus } from '@learningnodes/elen-core';
+export interface ElenConfig {
+    agentId: string;
+    projectId?: string;
+    storage?: 'memory' | 'sqlite';
+    sqlitePath?: string;
+    apiUrl?: string;
+    apiKey?: string;
+}
+export interface CommitDecisionInput {
+    question: string;
+    domain: string;
+    decisionText: string;
+    constraints: string[];
+    refs?: string[];
+    status?: DecisionStatus;
+    supersedesId?: string;
+}
+export interface SearchOptions {
+    domain?: string;
+    projectId?: string;
+    includeShared?: boolean;
+    query?: string;
+    limit?: number;
+}
+export interface SearchPrecedentsOptions {
+    limit?: number;
+}
+export type DecisionRecordResult = DecisionRecord;
+export type CompetencyProfileResult = CompetencyProfile;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@learningnodes/elen",
+  "version": "0.1.1",
+  "license": "AGPL-3.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@learningnodes/elen-core": "file:../core",
+    "better-sqlite3": "^11.7.0",
+    "nanoid": "^5.1.4"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.8"
+  }
+}

package/src/client.ts

@@ -0,0 +1,93 @@
+import {
+  decisionRecordSchema,
+  constraintSetSchema,
+  type DecisionRecord,
+  type ConstraintSet
+} from '@learningnodes/elen-core';
+import { createId, createDecisionId, createConstraintSetId } from './id';
+import type { StorageAdapter } from './storage';
+import type { CompetencyProfileResult, CommitDecisionInput, SearchOptions } from './types';
+
+export class ElenClient {
+  constructor(private readonly agentId: string, private readonly storage: StorageAdapter) { }
+
+  async commitDecision(input: CommitDecisionInput): Promise<DecisionRecord> {
+    const now = new Date().toISOString();
+
+    // 1. Resolve Constraints (Deterministic Hashing server-side)
+    const constraintSetId = createConstraintSetId(input.constraints);
+    const existingConstraints = await this.storage.getConstraintSet(constraintSetId);
+
+    if (!existingConstraints) {
+      const newSet: ConstraintSet = {
+        constraint_set_id: constraintSetId,
+        atoms: input.constraints,
+        summary: `Auto-generated summary for ${input.constraints.length} constraints`
+      };
+      constraintSetSchema.parse(newSet);
+      await this.storage.saveConstraintSet(newSet);
+    }
+
+    // 2. Build the Minimal Decision Atom
+    const record: DecisionRecord = {
+      decision_id: createDecisionId(input.domain),
+      q_id: createId('q'),
+      decision_text: input.decisionText,
+      constraint_set_id: constraintSetId,
+      refs: input.refs ?? [],
+      status: input.status ?? 'active',
+      supersedes_id: input.supersedesId,
+      timestamp: now,
+      agent_id: this.agentId,
+      domain: input.domain
+    };
+
+    decisionRecordSchema.parse(record);
+    await this.storage.saveRecord(record);
+
+    return record;
+  }
+
+  async supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<DecisionRecord> {
+    // 1. Mark old as superseded
+    const oldRecord = await this.storage.getRecord(oldDecisionId);
+    if (oldRecord) {
+      oldRecord.status = 'superseded';
+      await this.storage.saveRecord(oldRecord);
+    }
+
+    // 2. Commit new
+    return this.commitDecision({
+      ...input,
+      supersedesId: oldDecisionId
+    });
+  }
+
+  async suggest(opts: SearchOptions): Promise<Partial<DecisionRecord>[]> {
+    const fullRecords = await this.storage.searchRecords(opts);
+
+    // Pointer-first retrieval (minimal payload)
+    return fullRecords.map(r => ({
+      decision_id: r.decision_id,
+      status: r.status,
+      decision_text: r.decision_text,
+      constraint_set_id: r.constraint_set_id,
+      refs: r.refs,
+      supersedes_id: r.supersedes_id
+    }));
+  }
+
+  async expand(decisionId: string): Promise<{ record: DecisionRecord, constraints: ConstraintSet } | null> {
+    const record = await this.storage.getRecord(decisionId);
+    if (!record) return null;
+
+    const constraints = await this.storage.getConstraintSet(record.constraint_set_id);
+    if (!constraints) return null;
+
+    return { record, constraints };
+  }
+
+  async getCompetencyProfile(): Promise<CompetencyProfileResult> {
+    return this.storage.getCompetencyProfile(this.agentId);
+  }
+}

package/src/id.ts

@@ -0,0 +1,18 @@
+import { randomBytes, createHash } from 'node:crypto';
+
+export function createId(prefix: string): string {
+  return `${prefix}-${randomBytes(8).toString('base64url').slice(0, 10)}`;
+}
+
+export function createDecisionId(domain: string): string {
+  // Analytical Prefix: 3 chars domain + 'A' (Agent) + 'T3' (Routine Tier)
+  const d = domain.toUpperCase().replace(/[^A-Z]/g, '').padEnd(3, 'X').substring(0, 3);
+  const prefix = `${d}AT3`;
+  return `dec:${prefix}-${randomBytes(4).toString('base64url').slice(0, 6)}`;
+}
+
+export function createConstraintSetId(atoms: string[]): string {
+  const sorted = [...atoms].sort().join('|');
+  const hash = createHash('sha256').update(sorted).digest('hex').substring(0, 8);
+  return `cs:${hash}`;
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+import { ElenClient } from './client';
+import { InMemoryStorage, SQLiteStorage, type StorageAdapter } from './storage';
+import type { ElenConfig, CommitDecisionInput, SearchOptions } from './types';
+
+export class Elen {
+  private readonly client: ElenClient;
+
+  constructor(config: ElenConfig) {
+    const storage = this.createStorage(config);
+    this.client = new ElenClient(config.agentId, storage);
+  }
+
+  private createStorage(config: ElenConfig): StorageAdapter {
+    if (config.storage === 'sqlite') {
+      return new SQLiteStorage(config.sqlitePath ?? 'elen.db', config.projectId);
+    }
+
+    return new InMemoryStorage();
+  }
+
+  async commitDecision(input: CommitDecisionInput) {
+    return this.client.commitDecision(input);
+  }
+
+  async supersedeDecision(oldDecisionId: string, input: CommitDecisionInput) {
+    return this.client.supersedeDecision(oldDecisionId, input);
+  }
+
+  async suggest(opts: SearchOptions) {
+    return this.client.suggest(opts);
+  }
+
+  async expand(decisionId: string) {
+    return this.client.expand(decisionId);
+  }
+
+  async getCompetencyProfile() {
+    return this.client.getCompetencyProfile();
+  }
+}
+
+export * from './client';
+export * from './id';
+export * from './storage';
+export * from './types';

package/src/shims.d.ts

@@ -0,0 +1,27 @@
+declare module 'nanoid' {
+  export function nanoid(size?: number): string;
+}
+
+declare module 'better-sqlite3' {
+  interface Statement {
+    run(params?: unknown): unknown;
+    get(...params: unknown[]): unknown;
+    all(params?: unknown): unknown[];
+  }
+
+  interface DatabaseInstance {
+    exec(sql: string): void;
+    prepare(sql: string): Statement;
+  }
+
+  interface DatabaseConstructor {
+    new (path: string): DatabaseInstance;
+  }
+
+  const Database: DatabaseConstructor;
+  namespace Database {
+    export type Database = DatabaseInstance;
+  }
+
+  export default Database;
+}

package/src/storage/index.ts

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './memory';
+export * from './sqlite';

package/src/storage/interface.ts

@@ -0,0 +1,12 @@
+import type { CompetencyProfile, DecisionRecord, ConstraintSet } from '@learningnodes/elen-core';
+import type { SearchOptions } from '../types';
+
+export interface StorageAdapter {
+  saveConstraintSet(constraintSet: ConstraintSet): Promise<void>;
+  getConstraintSet(id: string): Promise<ConstraintSet | null>;
+  saveRecord(record: DecisionRecord): Promise<void>;
+  getRecord(recordId: string): Promise<DecisionRecord | null>;
+  searchRecords(opts: SearchOptions): Promise<DecisionRecord[]>;
+  getAgentDecisions(agentId: string, domain?: string): Promise<DecisionRecord[]>;
+  getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
+}

package/src/storage/memory.ts

@@ -0,0 +1,85 @@
+import type { CompetencyProfile, ConstraintSet, DecisionRecord } from '@learningnodes/elen-core';
+import type { SearchOptions } from '../types';
+import type { StorageAdapter } from './interface';
+
+export class InMemoryStorage implements StorageAdapter {
+  private readonly constraintSets = new Map<string, ConstraintSet>();
+  private readonly records = new Map<string, DecisionRecord>();
+
+  async saveConstraintSet(constraintSet: ConstraintSet): Promise<void> {
+    if (!this.constraintSets.has(constraintSet.constraint_set_id)) {
+      this.constraintSets.set(constraintSet.constraint_set_id, constraintSet);
+    }
+  }
+
+  async getConstraintSet(id: string): Promise<ConstraintSet | null> {
+    return this.constraintSets.get(id) ?? null;
+  }
+
+  async saveRecord(record: DecisionRecord): Promise<void> {
+    this.records.set(record.decision_id, record);
+  }
+
+  async getRecord(recordId: string): Promise<DecisionRecord | null> {
+    return this.records.get(recordId) ?? null;
+  }
+
+  async searchRecords(opts: SearchOptions): Promise<DecisionRecord[]> {
+    let results = Array.from(this.records.values());
+
+    if (opts.domain) {
+      results = results.filter((record) => record.domain === opts.domain);
+    }
+
+    if (opts.query) {
+      const needle = opts.query.toLowerCase();
+      results = results.filter((record) => {
+        const haystack = [
+          record.decision_text,
+          record.domain,
+          record.q_id
+        ].join(' ').toLowerCase();
+
+        return haystack.includes(needle);
+      });
+    }
+
+    const limit = opts.limit ?? results.length;
+
+    return results.sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, limit);
+  }
+
+  async getAgentDecisions(agentId: string, domain?: string): Promise<DecisionRecord[]> {
+    return Array.from(this.records.values()).filter(
+      (record) => record.agent_id === agentId && (domain ? record.domain === domain : true)
+    );
+  }
+
+  async getCompetencyProfile(agentId: string): Promise<CompetencyProfile> {
+    const records = await this.getAgentDecisions(agentId);
+    const domainCounts = new Map<string, number>();
+
+    for (const record of records) {
+      const count = domainCounts.get(record.domain) ?? 0;
+      domainCounts.set(record.domain, count + 1);
+    }
+
+    const domains = Array.from(domainCounts.keys());
+    const strengths: string[] = [];
+    const weaknesses: string[] = [];
+
+    for (const [domain, count] of domainCounts.entries()) {
+      if (count >= 5) {
+        strengths.push(domain);
+      }
+    }
+
+    return {
+      agent_id: agentId,
+      domains,
+      strengths,
+      weaknesses,
+      updated_at: new Date().toISOString()
+    };
+  }
+}