agent-working-memory 0.6.1 → 0.7.1

package/src/core/auto-tagger.ts

@@ -0,0 +1,168 @@
+// Copyright 2026 Robert Winter / Complete Ideas
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Auto-Tagger — generates meta-tags for memories at write time.
+ *
+ * Meta-tags serve as categorical signals that boost BM25 recall.
+ * They're indexed in FTS5 alongside concept/content/tags, so queries
+ * that match a category tag get better BM25 scores.
+ *
+ * Three sources of tags:
+ * 1. Content analysis — extract topics, entities, categories from the text
+ * 2. Context propagation — inherit relevant tags from related memories
+ * 3. Type classification — fact/experience/belief/entity markers
+ *
+ * Design: lightweight heuristics, no LLM calls. Tags are additive —
+ * they enrich the existing tag set without replacing user-provided tags.
+ */
+
+/**
+ * Extract meta-tags from memory content using keyword patterns.
+ * Returns tags prefixed with 'cat:' to distinguish from user tags.
+ */
+export function extractMetaTags(concept: string, content: string): string[] {
+  const tags: string[] = [];
+  const text = `${concept} ${content}`.toLowerCase();
+
+  // --- Category tags (broad topic classification) ---
+
+  // People / personal
+  if (/\b(i |my |i'm |i've |we |our |me )\b/.test(text)) {
+    tags.push('cat:personal');
+  }
+
+  // Work / professional
+  if (/\b(work|job|office|meeting|project|team|manager|colleague|career|salary|hired)\b/.test(text)) {
+    tags.push('cat:work');
+  }
+
+  // Technology / computing
+  if (/\b(code|programming|software|database|api|server|deploy|bug|git|typescript|python|react|node)\b/.test(text)) {
+    tags.push('cat:tech');
+  }
+
+  // Health / wellness
+  if (/\b(health|doctor|exercise|yoga|gym|diet|sleep|meditation|therapy|medicine|symptom)\b/.test(text)) {
+    tags.push('cat:health');
+  }
+
+  // Finance / money
+  if (/\b(money|budget|savings|invest|salary|cost|price|payment|bank|credit|expense|coupon|store|bought|purchased)\b/.test(text)) {
+    tags.push('cat:finance');
+  }
+
+  // Home / living
+  if (/\b(home|house|apartment|room|kitchen|bedroom|furniture|garden|repair|renovation|neighbor|moved)\b/.test(text)) {
+    tags.push('cat:home');
+  }
+
+  // Travel / location
+  if (/\b(travel|trip|vacation|flight|hotel|restaurant|city|country|visited|downtown|park)\b/.test(text)) {
+    tags.push('cat:location');
+  }
+
+  // Education / learning
+  if (/\b(school|university|college|degree|course|class|study|learn|graduate|student|teacher|exam)\b/.test(text)) {
+    tags.push('cat:education');
+  }
+
+  // Social / relationships
+  if (/\b(friend|family|partner|spouse|child|parent|sibling|birthday|party|dinner|wedding|date)\b/.test(text)) {
+    tags.push('cat:social');
+  }
+
+  // Hobbies / entertainment
+  if (/\b(music|movie|book|game|sport|hobby|play|concert|theater|playlist|podcast|guitar|tennis|yoga|painting)\b/.test(text)) {
+    tags.push('cat:hobby');
+  }
+
+  // Shopping / consumer
+  if (/\b(bought|purchased|ordered|shop|store|amazon|target|walmart|coupon|sale|discount|delivery)\b/.test(text)) {
+    tags.push('cat:shopping');
+  }
+
+  // Food / cooking
+  if (/\b(cook|recipe|restaurant|meal|food|dinner|lunch|breakfast|coffee|tea|bake|kitchen)\b/.test(text)) {
+    tags.push('cat:food');
+  }
+
+  // Pets / animals
+  if (/\b(pet|dog|cat|animal|vet|shelter|walk|breed)\b/.test(text)) {
+    tags.push('cat:pets');
+  }
+
+  // Time markers
+  if (/\b(yesterday|today|last week|last month|tomorrow|next week|this morning|this evening|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/.test(text)) {
+    tags.push('cat:temporal');
+  }
+
+  // --- Entity extraction (simple noun phrase patterns) ---
+
+  // Proper nouns (capitalized words that aren't sentence starters)
+  const properNouns = content.match(/(?:^|\.\s+)?([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)/g);
+  if (properNouns) {
+    const unique = [...new Set(properNouns.map(n => n.trim()).filter(n => n.length > 2 && n.length < 30))];
+    for (const noun of unique.slice(0, 5)) {
+      tags.push(`entity:${noun}`);
+    }
+  }
+
+  // --- Knowledge type tags ---
+
+  // Preference (I like/prefer/enjoy/love/hate)
+  if (/\b(i like|i prefer|i enjoy|i love|i hate|my favorite|i don't like)\b/.test(text)) {
+    tags.push('cat:preference');
+  }
+
+  // Fact (declarative statements about identity/attributes)
+  if (/\b(my name is|i am a|i work at|i live in|i graduated|my birthday|i was born)\b/.test(text)) {
+    tags.push('cat:identity');
+  }
+
+  // Plan / intention
+  if (/\b(i plan to|i'm going to|i want to|i'm thinking of|i'm considering|next week i|planning to)\b/.test(text)) {
+    tags.push('cat:plan');
+  }
+
+  // Experience / event
+  if (/\b(i went|i visited|i attended|i tried|i saw|i heard|i found|i discovered)\b/.test(text)) {
+    tags.push('cat:experience');
+  }
+
+  return tags;
+}
+
+/**
+ * Propagate relevant tags from related memories to a new memory.
+ * Called after connection engine links the new memory to existing ones.
+ *
+ * Strategy: inherit meta-tags from strongly connected neighbors,
+ * but only tags that appear in 2+ neighbors (consensus filtering).
+ */
+export function propagateTagsFromNeighbors(
+  existingTags: string[],
+  neighborTagSets: string[][],
+): string[] {
+  if (neighborTagSets.length === 0) return [];
+
+  // Count meta-tag occurrences across neighbors
+  const tagCounts = new Map<string, number>();
+  for (const tags of neighborTagSets) {
+    for (const tag of tags) {
+      if (tag.startsWith('cat:') || tag.startsWith('entity:')) {
+        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+      }
+    }
+  }
+
+  // Only propagate tags that appear in 2+ neighbors (consensus)
+  const propagated: string[] = [];
+  const existingSet = new Set(existingTags);
+  for (const [tag, count] of tagCounts) {
+    if (count >= 2 && !existingSet.has(tag)) {
+      propagated.push(tag);
+    }
+  }
+
+  return propagated.slice(0, 5); // Cap to avoid tag bloat
+}

package/src/core/hebbian.ts

@@ -30,14 +30,25 @@ export function strengthenAssociation(
 
 /**
  * Weaken an association weight due to lack of co-activation.
- * Called periodically by the connection engine.
+ * Uses power-law decay (DASH model) instead of exponential.
+ * Power law has a longer tail — old but valuable associations
+ * don't vanish as aggressively as exponential decay.
+ *
+ * DASH: weight = initial × (1 + t/scale)^(-exponent)
+ * vs exponential: weight = initial × 0.5^(t/halfLife)
+ *
+ * At 7 days: power-law retains ~58% vs exponential 50%
+ * At 30 days: power-law retains ~32% vs exponential 6%
+ * At 90 days: power-law retains ~20% vs exponential 0.02%
  */
 export function decayAssociation(
   currentWeight: number,
   daysSinceActivation: number,
-  halfLife: number = 7.0 // days
+  halfLife: number = 7.0 // scale parameter (days)
 ): number {
-  const decayFactor = Math.pow(0.5, daysSinceActivation / halfLife);
+  // Power-law decay: (1 + t/scale)^(-exponent)
+  const exponent = 0.8; // Controls steepness — 0.8 gives a good balance
+  const decayFactor = Math.pow(1 + daysSinceActivation / halfLife, -exponent);
   return Math.max(currentWeight * decayFactor, MIN_WEIGHT);
 }
 
@@ -91,3 +102,73 @@ export class CoActivationBuffer {
     this.buffer = [];
   }
 }
+
+/**
+ * Validation-gated Hebbian buffer (Kairos-inspired).
+ *
+ * Instead of strengthening associations immediately on co-activation,
+ * pairs are held pending until feedback arrives. This prevents hub toxicity
+ * from noisy co-retrieval — edges only strengthen when the retrieval was
+ * actually useful.
+ *
+ * - Positive feedback → strengthen the pending pairs
+ * - Negative feedback → slightly weaken them
+ * - No feedback within GATE_TIMEOUT_MS → discard (neutral)
+ */
+const GATE_TIMEOUT_MS = 60_000; // 60 seconds to receive feedback
+
+interface PendingHebbianUpdate {
+  pairs: [string, string][];
+  engramIds: string[];
+  timestamp: number;
+}
+
+export class ValidationGatedBuffer {
+  private pending: PendingHebbianUpdate[] = [];
+
+  /** Record co-activated pairs as pending (awaiting feedback validation) */
+  addPending(engramIds: string[], pairs: [string, string][]): void {
+    this.pending.push({ pairs, engramIds, timestamp: Date.now() });
+    // Evict expired entries
+    const cutoff = Date.now() - GATE_TIMEOUT_MS;
+    this.pending = this.pending.filter(p => p.timestamp > cutoff);
+  }
+
+  /**
+   * Resolve pending updates for an engram that received feedback.
+   * Returns pairs to strengthen (positive) or weaken (negative).
+   */
+  resolveFeedback(engramId: string, useful: boolean): { pairs: [string, string][]; signal: number } {
+    const cutoff = Date.now() - GATE_TIMEOUT_MS;
+    const matching: [string, string][] = [];
+
+    // Find all pending updates that include this engram and are still within the gate window
+    this.pending = this.pending.filter(p => {
+      if (p.timestamp < cutoff) return false; // expired
+      if (p.engramIds.includes(engramId)) {
+        matching.push(...p.pairs);
+        return false; // consumed
+      }
+      return true; // keep
+    });
+
+    // Deduplicate pairs
+    const seen = new Set<string>();
+    const unique: [string, string][] = [];
+    for (const [a, b] of matching) {
+      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push([a, b]);
+      }
+    }
+
+    return {
+      pairs: unique,
+      signal: useful ? 1.0 : -0.3, // positive = full strengthen, negative = slight weaken
+    };
+  }
+
+  /** Get count of pending updates (for stats) */
+  get pendingCount(): number { return this.pending.length; }
+}

package/src/core/query-expander.ts

@@ -15,7 +15,6 @@
 import { pipeline, type Text2TextGenerationPipeline } from '@huggingface/transformers';
 
 const MODEL_ID = 'Xenova/flan-t5-small';
-
 let instance: Text2TextGenerationPipeline | null = null;
 let initPromise: Promise<Text2TextGenerationPipeline> | null = null;
 

package/src/core/reranker.ts

@@ -23,7 +23,6 @@ import {
 
 const DEFAULT_MODEL = 'Xenova/ms-marco-MiniLM-L-6-v2';
 const MODEL_ID = process.env.AWM_RERANKER_MODEL || DEFAULT_MODEL;
-
 let tokenizer: PreTrainedTokenizer | null = null;
 let model: PreTrainedModel | null = null;
 let initPromise: Promise<void> | null = null;

package/src/engine/activation.ts

@@ -21,7 +21,7 @@
 
 import { randomUUID } from 'node:crypto';
 import { baseLevelActivation, softplus } from '../core/decay.js';
-import { strengthenAssociation, CoActivationBuffer } from '../core/hebbian.js';
+import { strengthenAssociation, CoActivationBuffer, ValidationGatedBuffer } from '../core/hebbian.js';
 import { embed, cosineSimilarity } from '../core/embeddings.js';
 import { rerank } from '../core/reranker.js';
 import { expandQuery } from '../core/query-expander.js';
@@ -163,10 +163,12 @@ function jaccard(a: Set<string>, b: Set<string>): number {
 export class ActivationEngine {
   private store: EngramStore;
   private coActivationBuffer: CoActivationBuffer;
+  readonly validationGate: ValidationGatedBuffer;
 
   constructor(store: EngramStore) {
     this.store = store;
     this.coActivationBuffer = new CoActivationBuffer(50);
+    this.validationGate = new ValidationGatedBuffer();
   }
 
   /**
@@ -181,14 +183,18 @@ export class ActivationEngine {
     const abstentionThreshold = query.abstentionThreshold ?? 0;
     const adaptive = resolveAdaptiveParams(query);
 
+    // Resolve workspace scope: if workspace is set, search across all agents in that workspace
+    const agentIds = query.workspace
+      ? this.store.getWorkspaceAgentIds(query.agentId, query.workspace)
+      : [query.agentId];
+    const isWorkspaceScoped = agentIds.length > 1;
+
     // Phase -1: Coref expansion — if query has pronouns, append recent entity names
-    // Helps conversational recall where "she/he/they/it" refers to a named entity.
     let queryContext = query.context;
     const pronounPattern = /\b(she|he|they|her|his|him|their|it|that|this|there)\b/i;
     if (pronounPattern.test(queryContext)) {
-      // Pull recent entity names from the agent's most-accessed memories
       try {
-        const recentEntities = this.store.getEngramsByAgent(query.agentId, 'active')
+        const recentEntities = this.store.getEngramsByAgents(agentIds, 'active')
           .sort((a, b) => b.accessCount - a.accessCount)
           .slice(0, 10)
           .flatMap(e => e.tags.filter(t => t.length >= 3 && !/^(session-|low-|D\d)/.test(t)))
@@ -228,9 +234,9 @@ export class ActivationEngine {
     // Two-pass BM25: (1) keyword-stripped query for precision, (2) expanded query for recall.
     const keywordQuery = Array.from(tokenize(query.context)).join(' ');
     const bm25Keyword = keywordQuery.length > 2
-      ? this.store.searchBM25WithRank(query.agentId, keywordQuery, limit * 3)
+      ? this.store.searchBM25WithRankMultiAgent(agentIds, keywordQuery, limit * 3)
       : [];
-    const bm25Expanded = this.store.searchBM25WithRank(query.agentId, searchContext, limit * 3);
+    const bm25Expanded = this.store.searchBM25WithRankMultiAgent(agentIds, searchContext, limit * 3);
 
     // Merge: take the best BM25 score per engram from either pass
     const bm25ScoreMap = new Map<string, number>();
@@ -246,8 +252,8 @@ export class ActivationEngine {
       engram, bm25Score: bm25ScoreMap.get(id) ?? 0,
     }));
 
-    const allActive = this.store.getEngramsByAgent(
-      query.agentId,
+    const allActive = this.store.getEngramsByAgents(
+      agentIds,
       query.includeStaging ? undefined : 'active',
       query.includeRetracted ?? false
     );
@@ -402,7 +408,7 @@ export class ActivationEngine {
       // Take top 5 feedback terms and re-search
       const extraTerms = Array.from(feedbackTerms).slice(0, 5).join(' ');
       if (extraTerms) {
-        const feedbackBM25 = this.store.searchBM25WithRank(query.agentId, `${searchContext} ${extraTerms}`, limit * 2);
+        const feedbackBM25 = this.store.searchBM25WithRankMultiAgent(agentIds, `${searchContext} ${extraTerms}`, limit * 2);
         for (const r of feedbackBM25) {
           if (!candidateMap.has(r.engram.id)) {
             candidateMap.set(r.engram.id, r.engram);
@@ -632,13 +638,21 @@ export class ActivationEngine {
 
     const activatedIds = results.map(r => r.engram.id);
 
-    // Side effects: touch, co-activate, Hebbian update (skip for internal/system calls)
+    // Side effects: touch, co-activate, defer Hebbian to validation gate (skip for internal/system calls)
     if (!query.internal) {
       for (const id of activatedIds) {
         this.store.touchEngram(id);
       }
       this.coActivationBuffer.pushBatch(activatedIds);
-      this.updateHebbianWeights();
+      // Validation-gated Hebbian: defer strengthening until feedback arrives
+      const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
+      const seen = new Set<string>();
+      const uniquePairs: [string, string][] = [];
+      for (const [a, b] of pairs) {
+        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+        if (!seen.has(key)) { seen.add(key); uniquePairs.push([a, b]); }
+      }
+      this.validationGate.addPending(activatedIds, uniquePairs);
 
       // Log activation event for eval
       const latencyMs = performance.now() - startTime;
@@ -658,10 +672,27 @@ export class ActivationEngine {
   }
 
   /**
-   * Beam search graph walk — replaces naive BFS.
-   * Scores paths (not just nodes), uses query-dependent edge filtering,
-   * and supports deeper exploration with focused beams.
+   * Multi-graph traversal (MAGMA-inspired).
+   *
+   * Instead of one beam search over all edge types, runs independent traversals
+   * per graph type with specialized scoring, then fuses the boosts.
+   *
+   * Four sub-graphs:
+   * - Semantic (connection + hebbian edges) → standard weight-based walk
+   * - Temporal (temporal edges) → recency-weighted (favor recent connections)
+   * - Causal (causal edges) → full weight walk (causal links are high-value)
+   * - Entity (bridge edges) → entity-tag-weighted walk
+   *
+   * Each sub-graph contributes independently to the final graph boost,
+   * weighted by configurable per-graph weights.
    */
+  private static readonly GRAPH_WEIGHTS = {
+    semantic: 0.40,   // connection + hebbian
+    temporal: 0.20,   // temporal edges
+    causal: 0.25,     // causal edges (high-value signal)
+    entity: 0.15,     // bridge edges
+  };
+
   private graphWalk(
     scored: { engram: Engram; score: number; phaseScores: PhaseScores; associations: Association[] }[],
     maxDepth: number,
@@ -670,85 +701,120 @@ export class ActivationEngine {
   ): void {
     const scoreMap = new Map(scored.map(s => [s.engram.id, s]));
     const MAX_TOTAL_BOOST = 0.25;
-    const BEAM_WIDTH = beamWidth;
 
-    // Seed the beam with high-scoring, text-relevant items
-    const beam = scored
-      .filter(item => item.phaseScores.textMatch >= 0.15)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, BEAM_WIDTH);
+    // Define which edge types belong to each sub-graph
+    const graphTypes: Record<string, string[]> = {
+      semantic: ['connection', 'hebbian'],
+      temporal: ['temporal'],
+      causal: ['causal'],
+      entity: ['bridge'],
+    };
+
+    // Run independent traversals per sub-graph, accumulate boosts
+    const boostAccum = new Map<string, number>(); // engramId → total boost
 
-    // Track which engrams have been explored (avoid cycles)
-    const explored = new Set<string>();
+    for (const [graphName, edgeTypes] of Object.entries(graphTypes)) {
+      const graphWeight = ActivationEngine.GRAPH_WEIGHTS[graphName as keyof typeof ActivationEngine.GRAPH_WEIGHTS];
+      const subBeamWidth = Math.max(3, Math.ceil(beamWidth * graphWeight));
 
-    for (let depth = 0; depth < maxDepth; depth++) {
-      const nextBeam: typeof beam = [];
+      // Seed beam
+      const beam = scored
+        .filter(item => item.phaseScores.textMatch >= 0.15)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, subBeamWidth);
+
+      const explored = new Set<string>();
+
+      for (let depth = 0; depth < maxDepth; depth++) {
+        const nextBeam: typeof beam = [];
 
-      for (const item of beam) {
-        if (explored.has(item.engram.id)) continue;
-        explored.add(item.engram.id);
+        for (const item of beam) {
+          if (explored.has(item.engram.id)) continue;
+          explored.add(item.engram.id);
 
-        // Get associations — for depth > 0, fetch from store if not in scored set
-        const associations = item.associations.length > 0
-          ? item.associations
-          : this.store.getAssociationsFor(item.engram.id);
+          const associations = item.associations.length > 0
+            ? item.associations
+            : this.store.getAssociationsFor(item.engram.id);
 
-        for (const assoc of associations) {
-          const neighborId = assoc.fromEngramId === item.engram.id
-            ? assoc.toEngramId
-            : assoc.fromEngramId;
+          // Filter to only edges of this sub-graph type
+          const relevantEdges = associations.filter(a => edgeTypes.includes(a.type));
 
-          if (explored.has(neighborId)) continue;
+          for (const assoc of relevantEdges) {
+            const neighborId = assoc.fromEngramId === item.engram.id
+              ? assoc.toEngramId
+              : assoc.fromEngramId;
 
-          const neighbor = scoreMap.get(neighborId);
-          if (!neighbor) continue;
+            if (explored.has(neighborId)) continue;
+            const neighbor = scoreMap.get(neighborId);
+            if (!neighbor) continue;
 
-          // Query-dependent edge filtering: neighbor must have SOME relevance
-          // (textMatch > 0.05 for deeper hops, relaxed from 0.1)
-          const relevanceFloor = depth === 0 ? 0.1 : 0.05;
-          if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
+            const relevanceFloor = depth === 0 ? 0.1 : 0.05;
+            if (neighbor.phaseScores.textMatch < relevanceFloor) continue;
 
-          // Skip if neighbor already at boost cap
-          if (neighbor.phaseScores.graphBoost >= MAX_TOTAL_BOOST) continue;
+            // Path score with graph-type-specific weighting
+            const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
+            let pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
 
-          // Path score: source score * edge weight * hop penalty^(depth+1)
-          const normalizedWeight = Math.min(assoc.weight, 5.0) / 5.0;
-          const pathScore = item.score * normalizedWeight * Math.pow(hopPenalty, depth + 1);
+            // Causal edges get a 2x boost — they represent verified reasoning chains
+            if (graphName === 'causal') pathScore *= 2.0;
 
-          const boost = Math.min(pathScore, 0.15, MAX_TOTAL_BOOST - neighbor.phaseScores.graphBoost);
-          if (boost > 0.001) {
-            neighbor.score += boost;
-            neighbor.phaseScores.graphBoost += boost;
-            nextBeam.push(neighbor);
+            // Weight by sub-graph importance
+            const boost = Math.min(pathScore * graphWeight, 0.15);
+            if (boost > 0.001) {
+              boostAccum.set(neighborId, (boostAccum.get(neighborId) ?? 0) + boost);
+              nextBeam.push(neighbor);
+            }
           }
         }
+
+        if (nextBeam.length === 0) break;
+        beam.length = 0;
+        beam.push(...nextBeam
+          .sort((a, b) => b.score - a.score)
+          .slice(0, subBeamWidth)
+        );
       }
+    }
 
-      // Prune beam for next depth level
-      if (nextBeam.length === 0) break;
-      beam.length = 0;
-      beam.push(...nextBeam
-        .sort((a, b) => b.score - a.score)
-        .slice(0, BEAM_WIDTH)
-      );
+    // Apply fused boosts to scored items
+    for (const [engramId, totalBoost] of boostAccum) {
+      const item = scoreMap.get(engramId);
+      if (!item) continue;
+      const capped = Math.min(totalBoost, MAX_TOTAL_BOOST - item.phaseScores.graphBoost);
+      if (capped > 0.001) {
+        item.score += capped;
+        item.phaseScores.graphBoost += capped;
+      }
     }
   }
 
-  private updateHebbianWeights(): void {
-    const pairs = this.coActivationBuffer.getCoActivatedPairs(10_000);
-    // Deduplicate pairs to prevent repeated strengthening
-    const seen = new Set<string>();
-    for (const [a, b] of pairs) {
-      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+  /**
+   * Resolve validation-gated Hebbian update for a specific engram.
+   * Called by memory_feedback — only strengthens when retrieval was useful.
+   * This prevents hub toxicity from noisy co-retrieval (Kairos-inspired).
+   */
+  resolveHebbianFeedback(engramId: string, useful: boolean): number {
+    const { pairs, signal } = this.validationGate.resolveFeedback(engramId, useful);
+    let updated = 0;
 
+    for (const [a, b] of pairs) {
       const existing = this.store.getAssociation(a, b) ?? this.store.getAssociation(b, a);
       const currentWeight = existing?.weight ?? 0.1;
-      const newWeight = strengthenAssociation(currentWeight);
-      this.store.upsertAssociation(a, b, newWeight, 'hebbian');
-      this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+
+      if (signal > 0) {
+        // Positive feedback → strengthen
+        const newWeight = strengthenAssociation(currentWeight, signal);
+        this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      } else {
+        // Negative feedback → slight weakening (decay by signal magnitude)
+        const newWeight = Math.max(0.001, currentWeight * (1 + signal)); // signal is -0.3
+        this.store.upsertAssociation(a, b, newWeight, 'hebbian');
+        this.store.upsertAssociation(b, a, newWeight, 'hebbian');
+      }
+      updated++;
     }
+    return updated;
   }
 
   private explain(phases: PhaseScores, engram: Engram, associations: Association[]): string {