@learningnodes/elen 0.1.1 → 0.1.2

package/dist/client.d.ts

@@ -1,15 +1,18 @@
-import { type DecisionRecord, type ConstraintSet } from '@learningnodes/elen-core';
+import { type MinimalDecisionRecord, type DecisionRecord, type ConstraintSet } from '@learningnodes/elen-core';
 import type { StorageAdapter } from './storage';
-import type { CompetencyProfileResult, CommitDecisionInput, SearchOptions } from './types';
+import type { CompetencyProfileResult, CommitDecisionInput, LogDecisionInput, SearchOptions } from './types';
 export declare class ElenClient {
     private readonly agentId;
     private readonly storage;
     constructor(agentId: string, storage: StorageAdapter);
-    commitDecision(input: CommitDecisionInput): Promise<DecisionRecord>;
-    supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<DecisionRecord>;
-    suggest(opts: SearchOptions): Promise<Partial<DecisionRecord>[]>;
+    logDecision(input: LogDecisionInput): Promise<DecisionRecord>;
+    commitDecision(input: CommitDecisionInput): Promise<MinimalDecisionRecord>;
+    supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<MinimalDecisionRecord>;
+    searchRecords(opts: SearchOptions): Promise<(import("@learningnodes/elen-core").DecisionRecordV0 | MinimalDecisionRecord)[]>;
+    searchPrecedents(query: string, opts?: SearchOptions): Promise<(import("@learningnodes/elen-core").DecisionRecordV0 | MinimalDecisionRecord)[]>;
+    suggest(opts: SearchOptions): Promise<Array<Partial<MinimalDecisionRecord>>>;
     expand(decisionId: string): Promise<{
-        record: DecisionRecord;
+        record: MinimalDecisionRecord;
         constraints: ConstraintSet;
     } | null>;
     getCompetencyProfile(): Promise<CompetencyProfileResult>;

package/dist/client.js

@@ -8,9 +8,71 @@ class ElenClient {
         this.agentId = agentId;
         this.storage = storage;
     }
+    async logDecision(input) {
+        if (input.constraints.length === 0)
+            throw new Error('Decision must include at least one constraint');
+        if (input.evidence.length === 0)
+            throw new Error('Decision must include at least one evidence');
+        const decisionId = (0, id_1.createDecisionId)(input.domain);
+        const now = new Date().toISOString();
+        const constraintsSnapshot = input.constraints.map((description, i) => ({
+            constraint_id: (0, id_1.createId)(`con${i}`),
+            decision_id: decisionId,
+            type: 'requirement',
+            description,
+            locked: false
+        }));
+        const evidenceSnapshot = input.evidence.map((e, i) => ({
+            evidence_id: (0, id_1.createId)(`evd${i}`),
+            decision_id: decisionId,
+            type: input.linkedPrecedents?.[i] ? 'precedent' : 'observation',
+            claim: e,
+            proof: e,
+            confidence: input.confidence?.[i] ?? 0.8,
+            linked_precedent: input.linkedPrecedents?.[i]
+        }));
+        const checksSnapshot = evidenceSnapshot.map((e, i) => ({
+            check_id: (0, id_1.createId)(`chk${i}`),
+            decision_id: decisionId,
+            claim: e.claim,
+            result: 'pass',
+            evidence_ids: [e.evidence_id],
+            epistemic_type: (0, elen_core_1.classifyEpistemicType)(e),
+            confidence: e.confidence
+        }));
+        const record = {
+            record_id: (0, id_1.createId)('rec'),
+            decision_id: decisionId,
+            agent_id: this.agentId,
+            question: input.question,
+            answer: input.answer,
+            constraints_snapshot: constraintsSnapshot,
+            evidence_snapshot: evidenceSnapshot,
+            checks_snapshot: checksSnapshot,
+            confidence: evidenceSnapshot.reduce((a, e) => a + e.confidence, 0) / evidenceSnapshot.length,
+            validation_type: 'self',
+            domain: input.domain,
+            tags: [],
+            published_at: now,
+            expires_at: null
+        };
+        await this.storage.saveDecision?.({
+            decision_id: decisionId,
+            agent_id: this.agentId,
+            question: input.question,
+            domain: input.domain,
+            status: 'validated',
+            constraints: constraintsSnapshot,
+            evidence: evidenceSnapshot,
+            checks: checksSnapshot,
+            created_at: now,
+            parent_prompt: input.parentPrompt
+        });
+        await this.storage.saveLegacyRecord?.(record);
+        return record;
+    }
     async commitDecision(input) {
         const now = new Date().toISOString();
-        // 1. Resolve Constraints (Deterministic Hashing server-side)
         const constraintSetId = (0, id_1.createConstraintSetId)(input.constraints);
         const existingConstraints = await this.storage.getConstraintSet(constraintSetId);
         if (!existingConstraints) {
@@ -22,10 +84,10 @@ class ElenClient {
             elen_core_1.constraintSetSchema.parse(newSet);
             await this.storage.saveConstraintSet(newSet);
         }
-        // 2. Build the Minimal Decision Atom
         const record = {
             decision_id: (0, id_1.createDecisionId)(input.domain),
             q_id: (0, id_1.createId)('q'),
+            question_text: input.question,
             decision_text: input.decisionText,
             constraint_set_id: constraintSetId,
             refs: input.refs ?? [],
@@ -35,30 +97,36 @@ class ElenClient {
             agent_id: this.agentId,
             domain: input.domain
         };
-        elen_core_1.decisionRecordSchema.parse(record);
+        elen_core_1.minimalDecisionRecordSchema.parse(record);
         await this.storage.saveRecord(record);
         return record;
     }
     async supersedeDecision(oldDecisionId, input) {
-        // 1. Mark old as superseded
         const oldRecord = await this.storage.getRecord(oldDecisionId);
-        if (oldRecord) {
+        if (oldRecord && 'status' in oldRecord) {
             oldRecord.status = 'superseded';
             await this.storage.saveRecord(oldRecord);
         }
-        // 2. Commit new
-        return this.commitDecision({
-            ...input,
-            supersedesId: oldDecisionId
-        });
+        return this.commitDecision({ ...input, supersedesId: oldDecisionId });
+    }
+    async searchRecords(opts) {
+        return this.storage.searchRecords(opts);
+    }
+    async searchPrecedents(query, opts = {}) {
+        const direct = await this.storage.searchRecords({ ...opts, query });
+        if (direct.length > 0)
+            return direct;
+        return this.storage.searchRecords({ ...opts, limit: opts.limit ?? 5 });
     }
     async suggest(opts) {
         const fullRecords = await this.storage.searchRecords(opts);
-        // Pointer-first retrieval (minimal payload)
-        return fullRecords.map(r => ({
+        return fullRecords
+            .filter((r) => 'decision_text' in r)
+            .map((r) => ({
             decision_id: r.decision_id,
             status: r.status,
             decision_text: r.decision_text,
+            question_text: r.question_text,
             constraint_set_id: r.constraint_set_id,
             refs: r.refs,
             supersedes_id: r.supersedes_id
@@ -66,7 +134,7 @@ class ElenClient {
     }
     async expand(decisionId) {
         const record = await this.storage.getRecord(decisionId);
-        if (!record)
+        if (!record || !('constraint_set_id' in record))
             return null;
         const constraints = await this.storage.getConstraintSet(record.constraint_set_id);
         if (!constraints)

package/dist/index.d.ts

@@ -1,13 +1,16 @@
-import type { ElenConfig, CommitDecisionInput, SearchOptions } from './types';
+import type { ElenConfig, CommitDecisionInput, LogDecisionInput, SearchOptions } from './types';
 export declare class Elen {
     private readonly client;
     constructor(config: ElenConfig);
     private createStorage;
-    commitDecision(input: CommitDecisionInput): Promise<import("@learningnodes/elen-core").DecisionRecord>;
-    supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<import("@learningnodes/elen-core").DecisionRecord>;
-    suggest(opts: SearchOptions): Promise<Partial<import("@learningnodes/elen-core").DecisionRecord>[]>;
+    logDecision(input: LogDecisionInput): Promise<import("@learningnodes/elen-core").DecisionRecordV0>;
+    commitDecision(input: CommitDecisionInput): Promise<import("@learningnodes/elen-core").MinimalDecisionRecord>;
+    supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<import("@learningnodes/elen-core").MinimalDecisionRecord>;
+    searchRecords(opts: SearchOptions): Promise<(import("@learningnodes/elen-core").DecisionRecordV0 | import("@learningnodes/elen-core").MinimalDecisionRecord)[]>;
+    searchPrecedents(query: string, opts?: SearchOptions): Promise<(import("@learningnodes/elen-core").DecisionRecordV0 | import("@learningnodes/elen-core").MinimalDecisionRecord)[]>;
+    suggest(opts: SearchOptions): Promise<Partial<import("@learningnodes/elen-core").MinimalDecisionRecord>[]>;
     expand(decisionId: string): Promise<{
-        record: import("@learningnodes/elen-core").DecisionRecord;
+        record: import("@learningnodes/elen-core").MinimalDecisionRecord;
         constraints: import("@learningnodes/elen-core").ConstraintSet;
     } | null>;
     getCompetencyProfile(): Promise<import("@learningnodes/elen-core").CompetencyProfile>;

package/dist/index.js

@@ -24,16 +24,25 @@ class Elen {
     }
     createStorage(config) {
         if (config.storage === 'sqlite') {
-            return new storage_1.SQLiteStorage(config.sqlitePath ?? 'elen.db', config.projectId);
+            return new storage_1.SQLiteStorage(config.sqlitePath ?? 'elen.db', config.projectId, config.defaultProjectIsolation ?? 'strict');
         }
         return new storage_1.InMemoryStorage();
     }
+    async logDecision(input) {
+        return this.client.logDecision(input);
+    }
     async commitDecision(input) {
         return this.client.commitDecision(input);
     }
     async supersedeDecision(oldDecisionId, input) {
         return this.client.supersedeDecision(oldDecisionId, input);
     }
+    async searchRecords(opts) {
+        return this.client.searchRecords(opts);
+    }
+    async searchPrecedents(query, opts = {}) {
+        return this.client.searchPrecedents(query, opts);
+    }
     async suggest(opts) {
         return this.client.suggest(opts);
     }

package/dist/storage/interface.d.ts

@@ -1,11 +1,13 @@
-import type { CompetencyProfile, DecisionRecord, ConstraintSet } from '@learningnodes/elen-core';
+import type { CompetencyProfile, ConstraintSet, DecisionContext, DecisionRecord, MinimalDecisionRecord } from '@learningnodes/elen-core';
 import type { SearchOptions } from '../types';
 export interface StorageAdapter {
+    saveDecision?(decision: DecisionContext): Promise<void>;
     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[]>;
+    saveRecord(record: MinimalDecisionRecord | DecisionRecord): Promise<void>;
+    saveLegacyRecord?(record: DecisionRecord): Promise<void>;
+    getRecord(recordId: string): Promise<MinimalDecisionRecord | DecisionRecord | null>;
+    searchRecords(opts: SearchOptions): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
+    getAgentDecisions(agentId: string, domain?: string): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
     getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
 }

package/dist/storage/memory.d.ts

@@ -1,14 +1,17 @@
-import type { CompetencyProfile, ConstraintSet, DecisionRecord } from '@learningnodes/elen-core';
+import type { CompetencyProfile, ConstraintSet, DecisionContext, DecisionRecord, MinimalDecisionRecord } from '@learningnodes/elen-core';
 import type { SearchOptions } from '../types';
 import type { StorageAdapter } from './interface';
 export declare class InMemoryStorage implements StorageAdapter {
     private readonly constraintSets;
     private readonly records;
+    private readonly decisions;
+    saveDecision(decision: DecisionContext): Promise<void>;
     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[]>;
+    saveRecord(record: MinimalDecisionRecord | DecisionRecord): Promise<void>;
+    saveLegacyRecord(record: DecisionRecord): Promise<void>;
+    getRecord(recordId: string): Promise<MinimalDecisionRecord | DecisionRecord | null>;
+    searchRecords(opts: SearchOptions): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
+    getAgentDecisions(agentId: string, domain?: string): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
     getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
 }

package/dist/storage/memory.js

@@ -5,65 +5,54 @@ class InMemoryStorage {
     constructor() {
         this.constraintSets = new Map();
         this.records = new Map();
-    }
-    async saveConstraintSet(constraintSet) {
-        if (!this.constraintSets.has(constraintSet.constraint_set_id)) {
-            this.constraintSets.set(constraintSet.constraint_set_id, constraintSet);
-        }
-    }
-    async getConstraintSet(id) {
-        return this.constraintSets.get(id) ?? null;
-    }
-    async saveRecord(record) {
-        this.records.set(record.decision_id, record);
-    }
-    async getRecord(recordId) {
-        return this.records.get(recordId) ?? null;
-    }
+        this.decisions = new Map();
+    }
+    async saveDecision(decision) { this.decisions.set(decision.decision_id, decision); }
+    async saveConstraintSet(constraintSet) { if (!this.constraintSets.has(constraintSet.constraint_set_id))
+        this.constraintSets.set(constraintSet.constraint_set_id, constraintSet); }
+    async getConstraintSet(id) { return this.constraintSets.get(id) ?? null; }
+    async saveRecord(record) { this.records.set(("record_id" in record ? record.record_id : record.decision_id), record); }
+    async saveLegacyRecord(record) { this.records.set(record.record_id, record); }
+    async getRecord(recordId) { return this.records.get(recordId) ?? null; }
     async searchRecords(opts) {
         let results = Array.from(this.records.values());
-        if (opts.domain) {
-            results = results.filter((record) => record.domain === opts.domain);
+        if (opts.domain)
+            results = results.filter((r) => r.domain === opts.domain);
+        if (typeof opts.minConfidence === 'number')
+            results = results.filter((r) => ('confidence' in r ? r.confidence >= opts.minConfidence : true));
+        if (opts.parentPrompt) {
+            const needle = opts.parentPrompt.toLowerCase();
+            results = results.filter((r) => {
+                const ctx = this.decisions.get(r.decision_id);
+                return ctx?.parent_prompt?.toLowerCase().includes(needle) ?? false;
+            });
         }
         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);
+            results = results.filter((r) => {
+                const haystack = 'decision_text' in r ? `${r.question_text ?? ''} ${r.decision_text} ${r.domain}` : `${r.question} ${r.answer} ${r.domain} ${r.constraints_snapshot.map(c => c.description).join(' ')} ${r.evidence_snapshot.map(e => `${e.claim} ${e.proof}`).join(' ')}`;
+                return haystack.toLowerCase().includes(needle);
             });
         }
         const limit = opts.limit ?? results.length;
-        return results.sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, limit);
+        return results.slice(0, limit);
     }
     async getAgentDecisions(agentId, domain) {
-        return Array.from(this.records.values()).filter((record) => record.agent_id === agentId && (domain ? record.domain === domain : true));
+        return Array.from(this.records.values()).filter((r) => r.agent_id === agentId && (domain ? r.domain === domain : true));
     }
     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 = [];
-        for (const [domain, count] of domainCounts.entries()) {
-            if (count >= 5) {
-                strengths.push(domain);
-            }
+        const stats = new Map();
+        for (const r of records) {
+            const cur = stats.get(r.domain) ?? { count: 0, conf: 0 };
+            cur.count += 1;
+            cur.conf += ("confidence" in r ? r.confidence : 0.8);
+            stats.set(r.domain, cur);
         }
-        return {
-            agent_id: agentId,
-            domains,
-            strengths,
-            weaknesses,
-            updated_at: new Date().toISOString()
-        };
+        const domains = [...stats.keys()];
+        const strengths = domains.filter((d) => { const s = stats.get(d); return s.count >= 1 && (s.conf / s.count) >= 0.7; });
+        const weaknesses = domains.filter((d) => { const s = stats.get(d); return (s.conf / s.count) < 0.7; });
+        return { agent_id: agentId, domains, strengths, weaknesses, updated_at: new Date().toISOString() };
     }
 }
 exports.InMemoryStorage = InMemoryStorage;

package/dist/storage/sqlite.d.ts

@@ -1,34 +1,19 @@
-import type { CompetencyProfile, DecisionRecord, ConstraintSet } from '@learningnodes/elen-core';
+import type { CompetencyProfile, ConstraintSet, DecisionContext, DecisionRecord, MinimalDecisionRecord } from '@learningnodes/elen-core';
 import type { SearchOptions } from '../types';
 import type { StorageAdapter } from './interface';
-export interface ProjectRecord {
-    project_id: string;
-    display_name: string;
-    source_hint: string | null;
-    created_at: string;
-}
-export interface ProjectSharingRecord {
-    source_project_id: string;
-    target_project_id: string;
-    direction: 'one-way' | 'bi-directional';
-    enabled: number;
-}
 export declare class SQLiteStorage implements StorageAdapter {
     private readonly db;
     private readonly projectId;
-    constructor(path: string, projectId?: string);
+    private readonly defaultIsolation;
+    constructor(path: string, projectId?: string, defaultIsolation?: 'strict' | 'open');
     private init;
-    private ensureProject;
-    getProjects(): ProjectRecord[];
-    getSharing(): ProjectSharingRecord[];
-    upsertSharing(source: string, target: string, direction: 'one-way' | 'bi-directional', enabled: boolean): void;
-    deleteSharing(source: string, target: string): void;
-    private getAccessibleProjects;
+    saveDecision(decision: DecisionContext): Promise<void>;
     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[]>;
+    saveRecord(record: MinimalDecisionRecord | DecisionRecord): Promise<void>;
+    saveLegacyRecord(record: DecisionRecord): Promise<void>;
+    getRecord(recordId: string): Promise<MinimalDecisionRecord | DecisionRecord | null>;
+    searchRecords(opts: SearchOptions): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
+    getAgentDecisions(agentId: string, domain?: string): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
     getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
 }