audrey 0.5.1 → 0.9.0

package/src/affect.js

@@ -0,0 +1,64 @@
+export function arousalSalienceBoost(arousal) {
+  if (arousal === undefined || arousal === null) return 0;
+  // Inverted-U (Yerkes-Dodson): peaks at 0.7, Gaussian sigma=0.3
+  return Math.exp(-Math.pow(arousal - 0.7, 2) / (2 * 0.3 * 0.3));
+}
+
+export function affectSimilarity(a, b) {
+  if (!a || !b) return 0;
+  if (a.valence === undefined || b.valence === undefined) return 0;
+  const valenceDist = Math.abs(a.valence - b.valence);
+  const valenceSim = 1.0 - (valenceDist / 2.0);
+  if (a.arousal === undefined || b.arousal === undefined) return valenceSim;
+  const arousalSim = 1.0 - Math.abs(a.arousal - b.arousal);
+  // Valence is primary (70%), arousal secondary (30%) per Bower 1981
+  return 0.7 * valenceSim + 0.3 * arousalSim;
+}
+
+export function moodCongruenceModifier(encodingAffect, retrievalMood, weight = 0.2) {
+  if (!encodingAffect || !retrievalMood) return 1.0;
+  const similarity = affectSimilarity(encodingAffect, retrievalMood);
+  if (similarity === 0) return 1.0;
+  return 1.0 + (weight * similarity);
+}
+
+export async function detectResonance(db, embeddingProvider, episodeId, { content, affect }, config = {}) {
+  const { enabled = true, k = 5, threshold = 0.5, affectThreshold = 0.6 } = config;
+  if (!enabled || !affect || affect.valence === undefined) return [];
+
+  const vector = await embeddingProvider.embed(content);
+  const buffer = embeddingProvider.vectorToBuffer(vector);
+
+  const matches = db.prepare(`
+    SELECT e.*, (1.0 - v.distance) AS similarity
+    FROM vec_episodes v
+    JOIN episodes e ON e.id = v.id
+    WHERE v.embedding MATCH ?
+      AND k = ?
+      AND e.id != ?
+      AND e.superseded_by IS NULL
+  `).all(buffer, k, episodeId);
+
+  const resonances = [];
+  for (const match of matches) {
+    if (match.similarity < threshold) continue;
+    let priorAffect;
+    try { priorAffect = JSON.parse(match.affect || '{}'); } catch { continue; }
+    if (priorAffect.valence === undefined) continue;
+
+    const emotionalSimilarity = affectSimilarity(affect, priorAffect);
+    if (emotionalSimilarity < affectThreshold) continue;
+
+    resonances.push({
+      priorEpisodeId: match.id,
+      priorContent: match.content,
+      priorAffect,
+      semanticSimilarity: match.similarity,
+      emotionalSimilarity,
+      timeDelta: Date.now() - new Date(match.created_at).getTime(),
+      priorCreatedAt: match.created_at,
+    });
+  }
+
+  return resonances;
+}

package/src/audrey.js

@@ -8,12 +8,15 @@ import { validateMemory } from './validate.js';
 import { runConsolidation } from './consolidate.js';
 import { applyDecay } from './decay.js';
 import { rollbackConsolidation, getConsolidationHistory } from './rollback.js';
+import { forgetMemory, forgetByQuery as forgetByQueryFn, purgeMemories } from './forget.js';
 import { introspect as introspectFn } from './introspect.js';
 import { buildContextResolutionPrompt } from './prompts.js';
 import { exportMemories } from './export.js';
 import { importMemories } from './import.js';
 import { suggestConsolidationParams as suggestParamsFn } from './adaptive.js';
 import { reembedAll } from './migrate.js';
+import { applyInterference } from './interference.js';
+import { detectResonance } from './affect.js';
 
 /**
  * @typedef {'direct-observation' | 'told-by-user' | 'tool-result' | 'inference' | 'model-generated'} SourceType
@@ -33,6 +36,10 @@ import { reembedAll } from './migrate.js';
  * @property {number} [limit]
  * @property {boolean} [includeProvenance]
  * @property {boolean} [includeDormant]
+ * @property {string[]} [tags]
+ * @property {string[]} [sources]
+ * @property {string} [after]
+ * @property {string} [before]
  *
  * @typedef {Object} RecallResult
  * @property {string} id
@@ -84,6 +91,9 @@ export class Audrey extends EventEmitter {
     confidence = {},
     consolidation = {},
     decay = {},
+    interference = {},
+    context = {},
+    affect = {},
   } = {}) {
     super();
 
@@ -108,12 +118,36 @@ export class Audrey extends EventEmitter {
       weights: confidence.weights,
       halfLives: confidence.halfLives,
       sourceReliability: confidence.sourceReliability,
+      interferenceWeight: interference.weight ?? 0.1,
+      contextWeight: context.weight ?? 0.3,
+      affectWeight: affect.weight ?? 0.2,
     };
     this.consolidationConfig = {
       minEpisodes: consolidation.minEpisodes || 3,
     };
     this.decayConfig = { dormantThreshold: decay.dormantThreshold || 0.1 };
     this._autoConsolidateTimer = null;
+    this.interferenceConfig = {
+      enabled: interference.enabled ?? true,
+      k: interference.k ?? 5,
+      threshold: interference.threshold ?? 0.6,
+      weight: interference.weight ?? 0.1,
+    };
+    this.contextConfig = {
+      enabled: context.enabled ?? true,
+      weight: context.weight ?? 0.3,
+    };
+    this.affectConfig = {
+      enabled: affect.enabled ?? true,
+      weight: affect.weight ?? 0.2,
+      arousalWeight: affect.arousalWeight ?? 0.3,
+      resonance: {
+        enabled: affect.resonance?.enabled ?? true,
+        k: affect.resonance?.k ?? 5,
+        threshold: affect.resonance?.threshold ?? 0.5,
+        affectThreshold: affect.resonance?.affectThreshold ?? 0.6,
+      },
+    };
   }
 
   async _ensureMigrated() {
@@ -153,8 +187,27 @@ export class Audrey extends EventEmitter {
    */
   async encode(params) {
     await this._ensureMigrated();
-    const id = await encodeEpisode(this.db, this.embeddingProvider, params);
+    const encodeParams = { ...params, arousalWeight: this.affectConfig.arousalWeight };
+    const id = await encodeEpisode(this.db, this.embeddingProvider, encodeParams);
     this.emit('encode', { id, ...params });
+    if (this.interferenceConfig.enabled) {
+      applyInterference(this.db, this.embeddingProvider, id, params, this.interferenceConfig)
+        .then(affected => {
+          if (affected.length > 0) {
+            this.emit('interference', { episodeId: id, affected });
+          }
+        })
+        .catch(err => this.emit('error', err));
+    }
+    if (this.affectConfig.enabled && this.affectConfig.resonance.enabled && params.affect?.valence !== undefined) {
+      detectResonance(this.db, this.embeddingProvider, id, params, this.affectConfig.resonance)
+        .then(echoes => {
+          if (echoes.length > 0) {
+            this.emit('resonance', { episodeId: id, affect: params.affect, echoes });
+          }
+        })
+        .catch(err => this.emit('error', err));
+    }
     this._emitValidation(id, params);
     return id;
   }
@@ -188,7 +241,7 @@ export class Audrey extends EventEmitter {
     await this._ensureMigrated();
     return recallFn(this.db, this.embeddingProvider, query, {
       ...options,
-      confidenceConfig: options.confidenceConfig ?? this.confidenceConfig,
+      confidenceConfig: this._recallConfig(options),
     });
   }
 
@@ -201,10 +254,21 @@ export class Audrey extends EventEmitter {
     await this._ensureMigrated();
     yield* recallStreamFn(this.db, this.embeddingProvider, query, {
       ...options,
-      confidenceConfig: options.confidenceConfig ?? this.confidenceConfig,
+      confidenceConfig: this._recallConfig(options),
     });
   }
 
+  _recallConfig(options) {
+    let config = options.confidenceConfig ?? this.confidenceConfig;
+    if (this.contextConfig.enabled && options.context) {
+      config = { ...config, retrievalContext: options.context };
+    }
+    if (this.affectConfig.enabled && options.mood) {
+      config = { ...config, retrievalMood: options.mood };
+    }
+    return config;
+  }
+
   /**
    * @param {{ minClusterSize?: number, similarityThreshold?: number, extractPrinciple?: Function, llmProvider?: import('./llm.js').LLMProvider }} [options]
    * @returns {Promise<ConsolidationResult>}
@@ -343,6 +407,25 @@ export class Audrey extends EventEmitter {
     return suggestParamsFn(this.db);
   }
 
+  forget(id, options = {}) {
+    const result = forgetMemory(this.db, id, options);
+    this.emit('forget', result);
+    return result;
+  }
+
+  async forgetByQuery(query, options = {}) {
+    await this._ensureMigrated();
+    const result = await forgetByQueryFn(this.db, this.embeddingProvider, query, options);
+    if (result) this.emit('forget', result);
+    return result;
+  }
+
+  purge() {
+    const result = purgeMemories(this.db);
+    this.emit('purge', result);
+    return result;
+  }
+
   /** @returns {void} */
   close() {
     this.stopAutoConsolidate();

package/src/confidence.js

@@ -67,8 +67,16 @@ export function recencyDecay(ageDays, halfLifeDays) {
  */
 export function retrievalReinforcement(retrievalCount, daysSinceRetrieval) {
   if (retrievalCount === 0) return 0;
-  const lambdaRet = Math.LN2 / 14; // 14-day half-life for retrieval decay
-  return Math.min(1.0, 0.3 * Math.log(1 + retrievalCount) * Math.exp(-lambdaRet * daysSinceRetrieval));
+  const lambdaRet = Math.LN2 / 14;
+  const baseReinforcement = 0.3 * Math.log(1 + retrievalCount);
+  const recencyWeight = Math.exp(-lambdaRet * daysSinceRetrieval);
+  const spacedBonus = Math.min(0.15, 0.02 * Math.log(1 + daysSinceRetrieval));
+  return Math.min(1.0, baseReinforcement * recencyWeight + spacedBonus);
+}
+
+export function salienceModifier(salience) {
+  const s = salience ?? 0.5;
+  return 0.5 + s;
 }
 
 /**

package/src/consolidate.js

@@ -152,6 +152,7 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
         embeddingBuffer,
         semanticId: generateId(),
         semanticNow: new Date().toISOString(),
+        maxSalience: Math.max(...cluster.map(ep => ep.salience ?? 0.5)),
       });
     }
 
@@ -168,8 +169,8 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
             id, content, embedding, state, evidence_episode_ids,
             evidence_count, supporting_count, source_type_diversity,
             consolidation_checkpoint, embedding_model, embedding_version,
-            consolidation_model, created_at
-          ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            consolidation_model, created_at, salience
+          ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `).run(
           entry.semanticId,
           entry.principle.content,
@@ -183,6 +184,7 @@ export async function runConsolidation(db, embeddingProvider, options = {}) {
           embeddingProvider.modelVersion,
           llmProvider?.modelName || null,
           entry.semanticNow,
+          entry.maxSalience,
         );
 
         db.prepare('INSERT INTO vec_semantics(id, embedding, state) VALUES (?, ?, ?)').run(

package/src/context.js

@@ -0,0 +1,15 @@
+export function contextMatchRatio(encodingContext, retrievalContext) {
+  if (!encodingContext || !retrievalContext) return 0;
+  const retrievalKeys = Object.keys(retrievalContext);
+  if (retrievalKeys.length === 0) return 0;
+  const sharedKeys = retrievalKeys.filter(k => k in encodingContext);
+  if (sharedKeys.length === 0) return 0;
+  const matches = sharedKeys.filter(k => encodingContext[k] === retrievalContext[k]).length;
+  return matches / retrievalKeys.length;
+}
+
+export function contextModifier(encodingContext, retrievalContext, weight = 0.3) {
+  if (!encodingContext || !retrievalContext) return 1.0;
+  const ratio = contextMatchRatio(encodingContext, retrievalContext);
+  return 1.0 + (weight * ratio);
+}

package/src/db.js

@@ -11,6 +11,8 @@ const SCHEMA = `
     source TEXT NOT NULL CHECK(source IN ('direct-observation','told-by-user','tool-result','inference','model-generated')),
     source_reliability REAL NOT NULL,
     salience REAL DEFAULT 0.5,
+    context TEXT DEFAULT '{}',
+    affect TEXT DEFAULT '{}',
     tags TEXT,
     causal_trigger TEXT,
     causal_consequence TEXT,
@@ -42,7 +44,9 @@ const SCHEMA = `
     created_at TEXT NOT NULL,
     last_reinforced_at TEXT,
     retrieval_count INTEGER DEFAULT 0,
-    challenge_count INTEGER DEFAULT 0
+    challenge_count INTEGER DEFAULT 0,
+    interference_count INTEGER DEFAULT 0,
+    salience REAL DEFAULT 0.5
   );
 
   CREATE TABLE IF NOT EXISTS procedures (
@@ -58,7 +62,9 @@ const SCHEMA = `
     embedding_version TEXT,
     created_at TEXT NOT NULL,
     last_reinforced_at TEXT,
-    retrieval_count INTEGER DEFAULT 0
+    retrieval_count INTEGER DEFAULT 0,
+    interference_count INTEGER DEFAULT 0,
+    salience REAL DEFAULT 0.5
   );
 
   CREATE TABLE IF NOT EXISTS causal_links (

package/src/decay.js

@@ -1,4 +1,5 @@
-import { computeConfidence, DEFAULT_HALF_LIVES } from './confidence.js';
+import { computeConfidence, DEFAULT_HALF_LIVES, salienceModifier } from './confidence.js';
+import { interferenceModifier } from './interference.js';
 import { daysBetween } from './utils.js';
 
 /**
@@ -13,7 +14,7 @@ export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
 
   const semantics = db.prepare(`
     SELECT id, supporting_count, contradicting_count, created_at,
-           last_reinforced_at, retrieval_count
+           last_reinforced_at, retrieval_count, interference_count, salience
     FROM semantics WHERE state = 'active'
   `).all();
 
@@ -26,7 +27,7 @@ export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
       ? daysBetween(sem.last_reinforced_at, now)
       : ageDays;
 
-    const confidence = computeConfidence({
+    let confidence = computeConfidence({
       sourceType: 'tool-result',
       supportingCount: sem.supporting_count || 0,
       contradictingCount: sem.contradicting_count || 0,
@@ -35,6 +36,9 @@ export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
       retrievalCount: sem.retrieval_count || 0,
       daysSinceRetrieval,
     });
+    confidence *= interferenceModifier(sem.interference_count || 0);
+    confidence *= salienceModifier(sem.salience ?? 0.5);
+    confidence = Math.max(0, Math.min(1, confidence));
 
     if (confidence < dormantThreshold) {
       markDormantSem.run('dormant', sem.id);
@@ -44,7 +48,7 @@ export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
 
   const procedures = db.prepare(`
     SELECT id, success_count, failure_count, created_at,
-           last_reinforced_at, retrieval_count
+           last_reinforced_at, retrieval_count, interference_count, salience
     FROM procedures WHERE state = 'active'
   `).all();
 
@@ -57,7 +61,7 @@ export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
       ? daysBetween(proc.last_reinforced_at, now)
       : ageDays;
 
-    const confidence = computeConfidence({
+    let confidence = computeConfidence({
       sourceType: 'tool-result',
       supportingCount: proc.success_count || 0,
       contradictingCount: proc.failure_count || 0,
@@ -66,6 +70,9 @@ export function applyDecay(db, { dormantThreshold = 0.1, halfLives } = {}) {
       retrievalCount: proc.retrieval_count || 0,
       daysSinceRetrieval,
     });
+    confidence *= interferenceModifier(proc.interference_count || 0);
+    confidence *= salienceModifier(proc.salience ?? 0.5);
+    confidence = Math.max(0, Math.min(1, confidence));
 
     if (confidence < dormantThreshold) {
       markDormantProc.run('dormant', proc.id);

package/src/encode.js

@@ -1,5 +1,6 @@
 import { generateId } from './ulid.js';
 import { sourceReliability } from './confidence.js';
+import { arousalSalienceBoost } from './affect.js';
 
 /**
  * @param {import('better-sqlite3').Database} db
@@ -14,6 +15,9 @@ export async function encodeEpisode(db, embeddingProvider, {
   causal,
   tags,
   supersedes,
+  context = {},
+  affect = {},
+  arousalWeight = 0.3,
 }) {
   if (!content || typeof content !== 'string') throw new Error('content must be a non-empty string');
   if (salience < 0 || salience > 1) throw new Error('salience must be between 0 and 1');
@@ -25,15 +29,20 @@ export async function encodeEpisode(db, embeddingProvider, {
   const id = generateId();
   const now = new Date().toISOString();
 
+  const boost = arousalSalienceBoost(affect.arousal);
+  const effectiveSalience = Math.min(1.0, salience + (boost * arousalWeight));
+
   const insertAndLink = db.transaction(() => {
     db.prepare(`
       INSERT INTO episodes (
-        id, content, embedding, source, source_reliability, salience,
+        id, content, embedding, source, source_reliability, salience, context, affect,
         tags, causal_trigger, causal_consequence, created_at,
         embedding_model, embedding_version, supersedes
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
-      id, content, embeddingBuffer, source, reliability, salience,
+      id, content, embeddingBuffer, source, reliability, effectiveSalience,
+      JSON.stringify(context),
+      JSON.stringify(affect),
       tags ? JSON.stringify(tags) : null,
       causal?.trigger || null, causal?.consequence || null,
       now, embeddingProvider.modelName, embeddingProvider.modelVersion,

package/src/forget.js

@@ -0,0 +1,111 @@
+export function forgetMemory(db, id, { purge = false } = {}) {
+  const episode = db.prepare('SELECT id FROM episodes WHERE id = ?').get(id);
+  if (episode) {
+    if (purge) {
+      db.prepare('DELETE FROM vec_episodes WHERE id = ?').run(id);
+      db.prepare('DELETE FROM episodes WHERE id = ?').run(id);
+    } else {
+      db.prepare("UPDATE episodes SET superseded_by = 'forgotten' WHERE id = ?").run(id);
+      db.prepare('DELETE FROM vec_episodes WHERE id = ?').run(id);
+    }
+    return { id, type: 'episodic', purged: purge };
+  }
+
+  const semantic = db.prepare('SELECT id FROM semantics WHERE id = ?').get(id);
+  if (semantic) {
+    if (purge) {
+      db.prepare('DELETE FROM vec_semantics WHERE id = ?').run(id);
+      db.prepare('DELETE FROM semantics WHERE id = ?').run(id);
+    } else {
+      db.prepare("UPDATE semantics SET state = 'superseded' WHERE id = ?").run(id);
+      db.prepare('DELETE FROM vec_semantics WHERE id = ?').run(id);
+    }
+    return { id, type: 'semantic', purged: purge };
+  }
+
+  const procedure = db.prepare('SELECT id FROM procedures WHERE id = ?').get(id);
+  if (procedure) {
+    if (purge) {
+      db.prepare('DELETE FROM vec_procedures WHERE id = ?').run(id);
+      db.prepare('DELETE FROM procedures WHERE id = ?').run(id);
+    } else {
+      db.prepare("UPDATE procedures SET state = 'superseded' WHERE id = ?").run(id);
+      db.prepare('DELETE FROM vec_procedures WHERE id = ?').run(id);
+    }
+    return { id, type: 'procedural', purged: purge };
+  }
+
+  throw new Error(`Memory not found: ${id}`);
+}
+
+export function purgeMemories(db) {
+  const deadEpisodes = db.prepare(
+    'SELECT id FROM episodes WHERE superseded_by IS NOT NULL'
+  ).all();
+  const deadSemantics = db.prepare(
+    "SELECT id FROM semantics WHERE state IN ('superseded', 'dormant', 'rolled_back')"
+  ).all();
+  const deadProcedures = db.prepare(
+    "SELECT id FROM procedures WHERE state IN ('superseded', 'dormant', 'rolled_back')"
+  ).all();
+
+  const purgeAll = db.transaction(() => {
+    for (const row of deadEpisodes) {
+      db.prepare('DELETE FROM vec_episodes WHERE id = ?').run(row.id);
+      db.prepare('DELETE FROM episodes WHERE id = ?').run(row.id);
+    }
+    for (const row of deadSemantics) {
+      db.prepare('DELETE FROM vec_semantics WHERE id = ?').run(row.id);
+      db.prepare('DELETE FROM semantics WHERE id = ?').run(row.id);
+    }
+    for (const row of deadProcedures) {
+      db.prepare('DELETE FROM vec_procedures WHERE id = ?').run(row.id);
+      db.prepare('DELETE FROM procedures WHERE id = ?').run(row.id);
+    }
+  });
+
+  purgeAll();
+
+  return {
+    episodes: deadEpisodes.length,
+    semantics: deadSemantics.length,
+    procedures: deadProcedures.length,
+  };
+}
+
+export async function forgetByQuery(db, embeddingProvider, query, { minSimilarity = 0.9, purge = false } = {}) {
+  const queryVector = await embeddingProvider.embed(query);
+  const queryBuffer = embeddingProvider.vectorToBuffer(queryVector);
+
+  const candidates = [];
+
+  const epMatch = db.prepare(`
+    SELECT e.id, (1.0 - v.distance) AS similarity, 'episodic' AS type
+    FROM vec_episodes v JOIN episodes e ON e.id = v.id
+    WHERE v.embedding MATCH ? AND k = 1 AND e.superseded_by IS NULL
+  `).get(queryBuffer);
+  if (epMatch) candidates.push(epMatch);
+
+  const semMatch = db.prepare(`
+    SELECT s.id, (1.0 - v.distance) AS similarity, 'semantic' AS type
+    FROM vec_semantics v JOIN semantics s ON s.id = v.id
+    WHERE v.embedding MATCH ? AND k = 1 AND (v.state = 'active' OR v.state = 'context_dependent')
+  `).get(queryBuffer);
+  if (semMatch) candidates.push(semMatch);
+
+  const procMatch = db.prepare(`
+    SELECT p.id, (1.0 - v.distance) AS similarity, 'procedural' AS type
+    FROM vec_procedures v JOIN procedures p ON p.id = v.id
+    WHERE v.embedding MATCH ? AND k = 1 AND (v.state = 'active' OR v.state = 'context_dependent')
+  `).get(queryBuffer);
+  if (procMatch) candidates.push(procMatch);
+
+  if (candidates.length === 0) return null;
+
+  candidates.sort((a, b) => b.similarity - a.similarity);
+  const best = candidates[0];
+
+  if (best.similarity < minSimilarity) return null;
+
+  return forgetMemory(db, best.id, { purge });
+}

package/src/index.js

@@ -1,5 +1,5 @@
 export { Audrey } from './audrey.js';
-export { computeConfidence, sourceReliability, DEFAULT_SOURCE_RELIABILITY, DEFAULT_WEIGHTS, DEFAULT_HALF_LIVES } from './confidence.js';
+export { computeConfidence, sourceReliability, salienceModifier, DEFAULT_SOURCE_RELIABILITY, DEFAULT_WEIGHTS, DEFAULT_HALF_LIVES } from './confidence.js';
 export { createEmbeddingProvider, MockEmbeddingProvider, OpenAIEmbeddingProvider } from './embedding.js';
 export { createLLMProvider, MockLLMProvider, AnthropicLLMProvider, OpenAILLMProvider } from './llm.js';
 export { recall, recallStream } from './recall.js';
@@ -14,3 +14,7 @@ export { exportMemories } from './export.js';
 export { importMemories } from './import.js';
 export { suggestConsolidationParams } from './adaptive.js';
 export { reembedAll } from './migrate.js';
+export { forgetMemory, forgetByQuery, purgeMemories } from './forget.js';
+export { applyInterference, interferenceModifier } from './interference.js';
+export { contextMatchRatio, contextModifier } from './context.js';
+export { arousalSalienceBoost, affectSimilarity, moodCongruenceModifier, detectResonance } from './affect.js';

package/src/interference.js

@@ -0,0 +1,51 @@
+export function interferenceModifier(interferenceCount, weight = 0.1) {
+  return 1 / (1 + weight * interferenceCount);
+}
+
+export async function applyInterference(db, embeddingProvider, episodeId, { content }, config = {}) {
+  const { enabled = true, k = 5, threshold = 0.6, weight = 0.1 } = config;
+
+  if (!enabled) return [];
+
+  const vector = await embeddingProvider.embed(content);
+  const buffer = embeddingProvider.vectorToBuffer(vector);
+
+  const semanticHits = db.prepare(`
+    SELECT s.id, s.interference_count, (1.0 - v.distance) AS similarity
+    FROM vec_semantics v
+    JOIN semantics s ON s.id = v.id
+    WHERE v.embedding MATCH ?
+      AND k = ?
+      AND (v.state = 'active' OR v.state = 'context_dependent')
+  `).all(buffer, k);
+
+  const proceduralHits = db.prepare(`
+    SELECT p.id, p.interference_count, (1.0 - v.distance) AS similarity
+    FROM vec_procedures v
+    JOIN procedures p ON p.id = v.id
+    WHERE v.embedding MATCH ?
+      AND k = ?
+      AND (v.state = 'active' OR v.state = 'context_dependent')
+  `).all(buffer, k);
+
+  const affected = [];
+
+  const updateSemantic = db.prepare('UPDATE semantics SET interference_count = ? WHERE id = ?');
+  const updateProcedural = db.prepare('UPDATE procedures SET interference_count = ? WHERE id = ?');
+
+  for (const hit of semanticHits) {
+    if (hit.similarity < threshold) continue;
+    const newCount = hit.interference_count + 1;
+    updateSemantic.run(newCount, hit.id);
+    affected.push({ id: hit.id, type: 'semantic', newCount, similarity: hit.similarity });
+  }
+
+  for (const hit of proceduralHits) {
+    if (hit.similarity < threshold) continue;
+    const newCount = hit.interference_count + 1;
+    updateProcedural.run(newCount, hit.id);
+    affected.push({ id: hit.id, type: 'procedural', newCount, similarity: hit.similarity });
+  }
+
+  return affected;
+}