@learningnodes/elen 0.1.1 → 0.1.3

package/dist/storage/sqlite.js

@@ -6,329 +6,96 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SQLiteStorage = void 0;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 class SQLiteStorage {
-    constructor(path, projectId = 'default') {
+    constructor(path, projectId = 'default', defaultIsolation = 'strict') {
         this.db = new better_sqlite3_1.default(path);
         this.projectId = projectId;
+        this.defaultIsolation = defaultIsolation;
         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]);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS constraint_sets (constraint_set_id TEXT PRIMARY KEY, atoms TEXT NOT NULL, summary TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS decisions (decision_id TEXT PRIMARY KEY, decision_json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS records (
+        record_id TEXT PRIMARY KEY,
+        decision_id TEXT,
+        agent_id TEXT NOT NULL,
+        domain TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        question_text TEXT,
+        decision_text TEXT,
+        confidence REAL,
+        payload_json TEXT NOT NULL
+      );
+    `);
     }
-    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];
+    async saveDecision(decision) {
+        this.db.prepare('INSERT OR REPLACE INTO decisions(decision_id, decision_json) VALUES (?,?)').run([decision.decision_id, JSON.stringify(decision)]);
     }
-    // --- 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()
-        });
+        this.db.prepare('INSERT OR IGNORE INTO constraint_sets(constraint_set_id, atoms, summary) VALUES (?,?,?)').run([constraintSet.constraint_set_id, JSON.stringify(constraintSet.atoms), constraintSet.summary]);
     }
     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
-        };
+        const row = this.db.prepare('SELECT * FROM constraint_sets WHERE constraint_set_id=?').get(id);
+        return row ? { constraint_set_id: row.constraint_set_id, atoms: JSON.parse(row.atoms), summary: row.summary } : null;
     }
     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)
-        });
+        if ("record_id" in record) {
+            await this.saveLegacyRecord(record);
+            return;
+        }
+        this.db.prepare('INSERT OR REPLACE INTO records(record_id, decision_id, agent_id, domain, project_id, question_text, decision_text, payload_json) VALUES (?,?,?,?,?,?,?,?)').run([record.decision_id, record.decision_id, record.agent_id, record.domain, this.projectId, record.question_text ?? null, record.decision_text, JSON.stringify(record)]);
+    }
+    async saveLegacyRecord(record) {
+        this.db.prepare('INSERT OR REPLACE INTO records(record_id, decision_id, agent_id, domain, project_id, question_text, decision_text, confidence, payload_json) VALUES (?,?,?,?,?,?,?,?,?)').run([record.record_id, record.decision_id, record.agent_id, record.domain, this.projectId, record.question, record.answer, record.confidence, JSON.stringify(record)]);
     }
     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);
+        const row = this.db.prepare('SELECT payload_json FROM records WHERE record_id=? OR decision_id=?').get([recordId, recordId]);
+        return row ? JSON.parse(row.payload_json) : null;
     }
     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;
-        }
+        let rows = this.db.prepare('SELECT payload_json, decision_id, project_id, confidence, question_text, decision_text, domain FROM records').all();
+        if (this.defaultIsolation === 'strict' || opts.includeShared === false)
+            rows = rows.filter(r => r.project_id === this.projectId);
+        if (opts.domain)
+            rows = rows.filter(r => r.domain === opts.domain);
+        if (typeof opts.minConfidence === 'number')
+            rows = rows.filter(r => r.confidence == null || r.confidence >= opts.minConfidence);
         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()
+            const q = opts.query.toLowerCase();
+            rows = rows.filter(r => { const p = JSON.parse(r.payload_json); const extra = p.constraints_snapshot ? `${p.constraints_snapshot.map((c) => c.description).join(' ')} ${p.evidence_snapshot.map((e) => `${e.claim} ${e.proof}`).join(' ')}` : ''; return `${r.question_text ?? ''} ${r.decision_text ?? ''} ${r.domain ?? ''} ${extra}`.toLowerCase().includes(q); });
+        }
+        let parsed = rows.map(r => JSON.parse(r.payload_json));
+        if (opts.parentPrompt) {
+            const needle = opts.parentPrompt.toLowerCase();
+            parsed = parsed.filter((r) => {
+                const d = this.db.prepare('SELECT decision_json FROM decisions WHERE decision_id=?').get(r.decision_id);
+                if (!d)
+                    return false;
+                const ctx = JSON.parse(d.decision_json);
+                return ctx.parent_prompt?.toLowerCase().includes(needle) ?? false;
             });
         }
-        catch {
-            // Non-critical: don't fail search if logging fails
-        }
-        return results;
+        return opts.limit ? parsed.slice(0, opts.limit) : parsed;
     }
     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));
+        const rows = this.db.prepare('SELECT payload_json FROM records WHERE agent_id=?').all([agentId]);
+        const parsed = rows.map(r => JSON.parse(r.payload_json));
+        return domain ? parsed.filter(r => r.domain === domain) : parsed;
     }
     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()
-        };
+        const stats = new Map();
+        for (const r of records) {
+            const c = stats.get(r.domain) ?? { count: 0, conf: 0 };
+            c.count += 1;
+            c.conf += ("confidence" in r ? r.confidence : 0.8);
+            stats.set(r.domain, c);
+        }
+        const domains = [...stats.keys()];
+        const strengths = domains.filter(d => { const s = stats.get(d); return (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.SQLiteStorage = SQLiteStorage;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { CompetencyProfile, DecisionRecord, DecisionStatus } from '@learningnodes/elen-core';
+import type { CompetencyProfile, DecisionRecord, DecisionStatus, ConstraintSet } from '@learningnodes/elen-core';
 export interface ElenConfig {
     agentId: string;
     projectId?: string;
@@ -6,6 +6,7 @@ export interface ElenConfig {
     sqlitePath?: string;
     apiUrl?: string;
     apiKey?: string;
+    defaultProjectIsolation?: 'strict' | 'open';
 }
 export interface CommitDecisionInput {
     question: string;
@@ -16,15 +17,31 @@ export interface CommitDecisionInput {
     status?: DecisionStatus;
     supersedesId?: string;
 }
+export interface LogDecisionInput {
+    question: string;
+    domain: string;
+    constraints: string[];
+    evidence: string[];
+    confidence?: number[];
+    answer: string;
+    parentPrompt?: string;
+    linkedPrecedents?: string[];
+}
 export interface SearchOptions {
     domain?: string;
     projectId?: string;
     includeShared?: boolean;
     query?: string;
     limit?: number;
+    minConfidence?: number;
+    parentPrompt?: string;
 }
 export interface SearchPrecedentsOptions {
     limit?: number;
 }
 export type DecisionRecordResult = DecisionRecord;
 export type CompetencyProfileResult = CompetencyProfile;
+export type ExpandedDecision = {
+    record: DecisionRecord;
+    constraints: ConstraintSet;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@learningnodes/elen",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "AGPL-3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
     "lint": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@learningnodes/elen-core": "file:../core",
+    "@learningnodes/elen-core": "^0.1.3",
     "better-sqlite3": "^11.7.0",
     "nanoid": "^5.1.4"
   },
@@ -18,5 +18,8 @@
     "@types/better-sqlite3": "^7.6.12",
     "typescript": "^5.6.3",
     "vitest": "^2.1.8"
+  },
+  "exports": {
+    ".": "./dist/index.js"
   }
-}
+}

package/src/client.ts

@@ -1,20 +1,93 @@
 import {
-  decisionRecordSchema,
+  minimalDecisionRecordSchema,
   constraintSetSchema,
+  classifyEpistemicType,
+  type MinimalDecisionRecord,
   type DecisionRecord,
-  type ConstraintSet
+  type ConstraintSet,
+  type Constraint,
+  type Evidence,
+  type Check
 } from '@learningnodes/elen-core';
 import { createId, createDecisionId, createConstraintSetId } from './id';
 import type { StorageAdapter } from './storage';
-import type { CompetencyProfileResult, CommitDecisionInput, SearchOptions } from './types';
+import type { CompetencyProfileResult, CommitDecisionInput, LogDecisionInput, SearchOptions } from './types';
 
 export class ElenClient {
   constructor(private readonly agentId: string, private readonly storage: StorageAdapter) { }
 
-  async commitDecision(input: CommitDecisionInput): Promise<DecisionRecord> {
+  async logDecision(input: LogDecisionInput): Promise<DecisionRecord> {
+    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 = createDecisionId(input.domain);
+    const now = new Date().toISOString();
+
+    const constraintsSnapshot: Constraint[] = input.constraints.map((description, i) => ({
+      constraint_id: createId(`con${i}`),
+      decision_id: decisionId,
+      type: 'requirement',
+      description,
+      locked: false
+    }));
+
+    const evidenceSnapshot: Evidence[] = input.evidence.map((e, i) => ({
+      evidence_id: 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: Check[] = evidenceSnapshot.map((e, i) => ({
+      check_id: createId(`chk${i}`),
+      decision_id: decisionId,
+      claim: e.claim,
+      result: 'pass',
+      evidence_ids: [e.evidence_id],
+      epistemic_type: classifyEpistemicType(e),
+      confidence: e.confidence
+    }));
+
+    const record: DecisionRecord = {
+      record_id: 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: CommitDecisionInput): Promise<MinimalDecisionRecord> {
     const now = new Date().toISOString();
 
-    // 1. Resolve Constraints (Deterministic Hashing server-side)
     const constraintSetId = createConstraintSetId(input.constraints);
     const existingConstraints = await this.storage.getConstraintSet(constraintSetId);
 
@@ -28,10 +101,10 @@ export class ElenClient {
       await this.storage.saveConstraintSet(newSet);
     }
 
-    // 2. Build the Minimal Decision Atom
-    const record: DecisionRecord = {
+    const record: MinimalDecisionRecord = {
       decision_id: createDecisionId(input.domain),
       q_id: createId('q'),
+      question_text: input.question,
       decision_text: input.decisionText,
       constraint_set_id: constraintSetId,
       refs: input.refs ?? [],
@@ -42,44 +115,50 @@ export class ElenClient {
       domain: input.domain
     };
 
-    decisionRecordSchema.parse(record);
+    minimalDecisionRecordSchema.parse(record);
     await this.storage.saveRecord(record);
 
     return record;
   }
 
-  async supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<DecisionRecord> {
-    // 1. Mark old as superseded
+  async supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<MinimalDecisionRecord> {
     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 suggest(opts: SearchOptions): Promise<Partial<DecisionRecord>[]> {
-    const fullRecords = await this.storage.searchRecords(opts);
+  async searchRecords(opts: SearchOptions) {
+    return 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 searchPrecedents(query: string, opts: SearchOptions = {}) {
+    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: SearchOptions): Promise<Array<Partial<MinimalDecisionRecord>>> {
+    const fullRecords = await this.storage.searchRecords(opts);
+    return fullRecords
+      .filter((r): r is MinimalDecisionRecord => '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
+      }));
   }
 
-  async expand(decisionId: string): Promise<{ record: DecisionRecord, constraints: ConstraintSet } | null> {
+  async expand(decisionId: string): Promise<{ record: MinimalDecisionRecord, constraints: ConstraintSet } | null> {
     const record = await this.storage.getRecord(decisionId);
-    if (!record) return null;
+    if (!record || !('constraint_set_id' in record)) return null;
 
     const constraints = await this.storage.getConstraintSet(record.constraint_set_id);
     if (!constraints) return null;