open-agents-ai 0.187.509 → 0.187.511

package/dist/index.js

@@ -516650,6 +516650,15 @@ function clamp(x, lo, hi) {
     return hi;
   return x;
 }
+function clamp01(x) {
+  if (!Number.isFinite(x))
+    return 0;
+  if (x < 0)
+    return 0;
+  if (x > 1)
+    return 1;
+  return x;
+}
 function sanitizeEmotionalState(raw) {
   if (!raw)
     return { valence: 0, arousal: 0 };
@@ -516692,21 +516701,29 @@ function modulateRetrievalScore(baseScore, current, memory, tuning = DEFAULT_RET
     return baseScore;
   return baseScore * congruenceMultiplier(current, memory, tuning);
 }
-function createHomeostaticState(initial, target = DEFAULT_TARGET, windowSize = DEFAULT_WINDOW) {
+function createHomeostaticState(initial, target = DEFAULT_TARGET, windowSize = DEFAULT_WINDOW, regulationRate = 0) {
   const current = sanitizeEmotionalState(initial ?? { valence: 0, arousal: 0 });
   return {
     current,
     streak: 1,
     target: sanitizeEmotionalState(target),
     recent: [current],
-    windowSize: Math.max(1, Math.floor(windowSize))
+    windowSize: Math.max(1, Math.floor(windowSize)),
+    regulationRate: clamp01(regulationRate)
   };
 }
 function inSameBand(a2, b) {
   return Math.abs(clampValence(a2.valence) - clampValence(b.valence)) < STREAK_TOLERANCE && Math.abs(clampArousal(a2.arousal) - clampArousal(b.arousal)) < STREAK_TOLERANCE;
 }
 function observeEmotionalState(prev, next) {
-  const sample = sanitizeEmotionalState(next);
+  const raw = sanitizeEmotionalState(next);
+  const r2 = clamp01(prev.regulationRate ?? 0);
+  const drifted = r2 === 0 ? raw : {
+    valence: raw.valence + (prev.target.valence - raw.valence) * r2,
+    arousal: raw.arousal + (prev.target.arousal - raw.arousal) * r2,
+    emotion: raw.emotion
+  };
+  const sample = sanitizeEmotionalState(drifted);
   const continued = inSameBand(prev.current, sample);
   const recent = [sample, ...prev.recent].slice(0, prev.windowSize);
   return {
@@ -516740,6 +516757,26 @@ function suggestRegulation(state) {
     return "anchor-attention";
   return null;
 }
+function suggestRegulationActions(state) {
+  const out = [];
+  const dv = clampValence(state.current.valence) - clampValence(state.target.valence);
+  const da = clampArousal(state.current.arousal) - clampArousal(state.target.arousal);
+  const NEAR = 0.15;
+  if (state.streak > 8 && Math.abs(dv) >= NEAR) {
+    out.push(dv < 0 ? "seek-positive-experience" : "introduce-novelty");
+  }
+  if (da > NEAR && state.current.arousal > 0.85)
+    out.push("calming-activity");
+  if (da < -NEAR && state.current.arousal < 0.15)
+    out.push("energizing-activity");
+  if (dv < -NEAR && !out.includes("seek-positive-experience"))
+    out.push("self-compassion");
+  if (dv > NEAR && !out.includes("introduce-novelty"))
+    out.push("anchor-attention");
+  if (out.length === 0 && state.streak > 12)
+    out.push("introduce-novelty");
+  return out;
+}
 var DEFAULT_ENCODING, DEFAULT_RETRIEVAL, clampValence, clampArousal, DEFAULT_TARGET, DEFAULT_WINDOW, STREAK_TOLERANCE;
 var init_homeostaticRegulation = __esm({
   "packages/memory/dist/homeostaticRegulation.js"() {
@@ -516761,6 +516798,148 @@ var init_homeostaticRegulation = __esm({
   }
 });
 
+// packages/memory/dist/socialInfluence.js
+function clamp2(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function clamp012(x) {
+  return clamp2(x, 0, 1);
+}
+function conformityBias(myConfidence, groupAgreement, memoryAlignsWithGroup, weight = 0.5) {
+  const conf = clamp012(myConfidence);
+  const agree = clamp012(groupAgreement);
+  const w = clamp012(weight);
+  const pull = (agree - 0.5) * 2 * conf * w;
+  return memoryAlignsWithGroup ? 1 + pull : 1 - pull;
+}
+function authorityBias(sourceTrust, weight = 0.4) {
+  const t2 = clamp012(sourceTrust);
+  const w = clamp012(weight);
+  return 1 + (t2 - 0.5) * 2 * w;
+}
+function noveltyBias(memoryDivergence, weight = 0.3) {
+  const d2 = clamp012(memoryDivergence);
+  const w = clamp012(weight);
+  return 1 + d2 * w;
+}
+function reciprocityBias(relationshipStrength, relationshipValence, weight = 0.3) {
+  const s2 = clamp012(relationshipStrength);
+  const v = clamp2(relationshipValence, -1, 1);
+  const w = clamp012(weight);
+  return 1 + s2 * v * w;
+}
+function applyInfluence(baseScore, ctx3) {
+  let m2 = 1;
+  if (ctx3.myConfidence != null && ctx3.groupAgreement != null && ctx3.memoryAlignsWithGroup != null) {
+    m2 *= conformityBias(ctx3.myConfidence, ctx3.groupAgreement, ctx3.memoryAlignsWithGroup, ctx3.weights?.conformity);
+  }
+  if (ctx3.sourceTrust != null) {
+    m2 *= authorityBias(ctx3.sourceTrust, ctx3.weights?.authority);
+  }
+  if (ctx3.memoryDivergence != null) {
+    m2 *= noveltyBias(ctx3.memoryDivergence, ctx3.weights?.novelty);
+  }
+  if (ctx3.relationshipStrength != null && ctx3.relationshipValence != null) {
+    m2 *= reciprocityBias(ctx3.relationshipStrength, ctx3.relationshipValence, ctx3.weights?.reciprocity);
+  }
+  return baseScore * m2;
+}
+var init_socialInfluence = __esm({
+  "packages/memory/dist/socialInfluence.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/embodiedTrace.js
+function clamp3(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function clamp013(x) {
+  return clamp3(x, 0, 1);
+}
+function nonNegative(x) {
+  if (!Number.isFinite(x) || x < 0)
+    return 0;
+  return x;
+}
+function buildTrace(input) {
+  const i2 = input ?? {};
+  const used = nonNegative(i2.contextTokensUsed ?? DEFAULT_TRACE.contextTokensUsed);
+  const max = nonNegative(i2.contextTokensMax ?? DEFAULT_TRACE.contextTokensMax);
+  const derivedLoad = max > 0 ? used / max : 0;
+  const load2 = i2.cognitiveLoad != null ? clamp013(i2.cognitiveLoad) : clamp013(derivedLoad);
+  return {
+    durationMs: nonNegative(i2.durationMs ?? DEFAULT_TRACE.durationMs),
+    hesitationCount: Math.max(0, Math.floor(i2.hesitationCount ?? 0)),
+    retryCount: Math.max(0, Math.floor(i2.retryCount ?? 0)),
+    intensity: clamp013(i2.intensity ?? DEFAULT_TRACE.intensity),
+    visualGist: typeof i2.visualGist === "string" ? i2.visualGist : void 0,
+    auditoryGist: typeof i2.auditoryGist === "string" ? i2.auditoryGist : void 0,
+    screenState: typeof i2.screenState === "string" ? i2.screenState : void 0,
+    confidence: clamp013(i2.confidence ?? DEFAULT_TRACE.confidence),
+    cognitiveLoad: load2,
+    contextTokensUsed: used,
+    contextTokensMax: max,
+    affect: sanitizeEmotionalState(i2.affect ?? NEUTRAL_AFFECT),
+    timeOfDay: clamp3(Math.floor(i2.timeOfDay ?? DEFAULT_TRACE.timeOfDay), 0, 23),
+    sessionDurationMin: nonNegative(i2.sessionDurationMin ?? 0),
+    consecutiveActions: Math.max(0, Math.floor(i2.consecutiveActions ?? 0))
+  };
+}
+function attachTrace(metadata, trace) {
+  return { ...metadata ?? {}, [EMBODIED_KEY]: trace };
+}
+function extractTrace(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const raw = metadata[EMBODIED_KEY];
+  if (!raw || typeof raw !== "object")
+    return null;
+  return buildTrace(raw);
+}
+function engagementScore(trace) {
+  const alertness = 1 - trace.cognitiveLoad;
+  return clamp013((trace.intensity + alertness + trace.confidence) / 3);
+}
+function wasHesitant(trace, threshold = 0.4) {
+  return trace.hesitationCount >= 2 || trace.retryCount >= 1 || trace.confidence < threshold;
+}
+var NEUTRAL_AFFECT, DEFAULT_TRACE, EMBODIED_KEY;
+var init_embodiedTrace = __esm({
+  "packages/memory/dist/embodiedTrace.js"() {
+    "use strict";
+    init_homeostaticRegulation();
+    NEUTRAL_AFFECT = { valence: 0, arousal: 0 };
+    DEFAULT_TRACE = {
+      durationMs: 0,
+      hesitationCount: 0,
+      retryCount: 0,
+      intensity: 0,
+      confidence: 0.5,
+      cognitiveLoad: 0,
+      contextTokensUsed: 0,
+      contextTokensMax: 0,
+      affect: NEUTRAL_AFFECT,
+      timeOfDay: 0,
+      sessionDurationMin: 0,
+      consecutiveActions: 0
+    };
+    EMBODIED_KEY = "embodiedTrace";
+  }
+});
+
 // packages/memory/dist/pprRetrieval.js
 function readEpisodeAffect(metadata) {
   if (!metadata || typeof metadata !== "object")
@@ -516957,14 +517136,30 @@ function retrieveByPPR(query, graph, episodeStore, config) {
     }
   }
   let entries = [...episodeScores.entries()];
-  if (cfg.currentEmotionalState) {
+  const engagementWeight = cfg.engagementWeight ?? 0;
+  if (cfg.currentEmotionalState || cfg.influenceFor || engagementWeight !== 0) {
     const current = cfg.currentEmotionalState;
     entries = entries.map(([epId, payload]) => {
       const ep = episodeStore.get(epId);
-      const memoryAffect = ep ? readEpisodeAffect(ep.metadata) : null;
-      if (!memoryAffect)
-        return [epId, payload];
-      return [epId, { ...payload, score: modulateRetrievalScore(payload.score, current, memoryAffect) }];
+      let score = payload.score;
+      if (current) {
+        const memoryAffect = ep ? readEpisodeAffect(ep.metadata) : null;
+        if (memoryAffect)
+          score = modulateRetrievalScore(score, current, memoryAffect);
+      }
+      if (cfg.influenceFor) {
+        const ctx3 = cfg.influenceFor(epId);
+        if (ctx3)
+          score = applyInfluence(score, ctx3);
+      }
+      if (engagementWeight !== 0 && ep) {
+        const trace = extractTrace(ep.metadata);
+        if (trace) {
+          const eng = engagementScore(trace);
+          score = score * (1 + (eng - 0.5) * engagementWeight);
+        }
+      }
+      return [epId, { ...payload, score }];
     });
   }
   const ranked = entries.sort((a2, b) => b[1].score - a2[1].score).slice(0, cfg.topK);
@@ -516988,6 +517183,8 @@ var init_pprRetrieval = __esm({
     "use strict";
     init_zettelkasten();
     init_homeostaticRegulation();
+    init_socialInfluence();
+    init_embodiedTrace();
     DEFAULT_CONFIG4 = {
       damping: 0.5,
       maxIterations: 50,
@@ -517013,6 +517210,28 @@ function readEpisodeAffect2(metadata) {
     return null;
   return sanitizeEmotionalState(affect);
 }
+function readEpisodeEngagement(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const trace = metadata["embodiedTrace"];
+  if (!trace || typeof trace !== "object")
+    return null;
+  const t2 = trace;
+  const intensity = typeof t2["intensity"] === "number" ? clamp01Local(t2["intensity"]) : 0;
+  const cogLoad = typeof t2["cognitiveLoad"] === "number" ? clamp01Local(t2["cognitiveLoad"]) : 0;
+  const conf = typeof t2["confidence"] === "number" ? clamp01Local(t2["confidence"]) : 0.5;
+  const alertness = 1 - cogLoad;
+  return clamp01Local((intensity + alertness + conf) / 3);
+}
+function clamp01Local(x) {
+  if (!Number.isFinite(x))
+    return 0;
+  if (x < 0)
+    return 0;
+  if (x > 1)
+    return 1;
+  return x;
+}
 function sanitizeImportance(raw, fallback = 5) {
   if (typeof raw !== "number" || !Number.isFinite(raw))
     return fallback;
@@ -517081,6 +517300,7 @@ var init_episodeStore = __esm({
     init_db();
     init_zettelkasten();
     init_homeostaticRegulation();
+    init_socialInfluence();
     init_pprRetrieval();
     DECAY_TAU = {
       session: 36e5,
@@ -517102,6 +517322,22 @@ var init_episodeStore = __esm({
       graph = null;
       /** WO-AM-05: Zettelkasten config for neighbor linking */
       zettelConfig = { topK: 5, minSimilarity: 0.7, evolutionThreshold: 0.6, maxLinksPerEpisode: 10 };
+      /** AUDIT-3 (A2 completion): minimum importance an inserted episode must
+       *  meet (or beat) to actually persist. When 0 (default), all episodes
+       *  pass the gate — preserves backward-compatible behavior. The
+       *  orchestrator sets this from `MemoryStageContext.importanceFloor()`
+       *  so wisdom-stage agents store fewer routine episodes than
+       *  exploration-stage agents. */
+      importanceFloor = 0;
+      /** AUDIT-3: opt-in setter so the orchestrator can override the
+       *  hardcoded zettelConfig at session start (and after sleep
+       *  consolidation) with stage-derived values. */
+      setZettelConfig(partial) {
+        this.zettelConfig = { ...this.zettelConfig, ...partial };
+      }
+      setImportanceFloor(floor) {
+        this.importanceFloor = Number.isFinite(floor) && floor > 0 ? floor : 0;
+      }
       constructor(dbPath, graph, zettelConfig) {
         const dir = dbPath === ":memory:" ? null : join75(dbPath, "..");
         if (dir && !existsSync59(dir))
@@ -517153,6 +517389,9 @@ var init_episodeStore = __esm({
         const rawImportance = ep.importance ?? autoImportance(ep.toolName ?? null, modality, ep.content);
         const modulated = ep.emotionalState ? modulateImportance(sanitizeImportance(rawImportance), ep.emotionalState) : sanitizeImportance(rawImportance);
         const importance = sanitizeImportance(modulated);
+        if (this.importanceFloor > 0 && importance < this.importanceFloor) {
+          return "";
+        }
         const decayClass = ep.decayClass ?? autoDecayClass(ep.toolName ?? null, modality, ep.content);
         const existing = this.db.prepare("SELECT id FROM episodes WHERE content_hash = ? AND session_id = ? LIMIT 1").get(contentHash, ep.sessionId ?? null);
         if (existing)
@@ -517277,7 +517516,18 @@ var init_episodeStore = __esm({
           if (opts.currentEmotionalState) {
             const memoryAffect = readEpisodeAffect2(ep.metadata);
             if (memoryAffect) {
-              score = modulateRetrievalScore(baseScore, opts.currentEmotionalState, memoryAffect);
+              score = modulateRetrievalScore(score, opts.currentEmotionalState, memoryAffect);
+            }
+          }
+          if (opts.influenceFor) {
+            const ctx3 = opts.influenceFor(ep);
+            if (ctx3)
+              score = applyInfluence(score, ctx3);
+          }
+          if ((opts.engagementWeight ?? 0) !== 0) {
+            const eng = readEpisodeEngagement(ep.metadata);
+            if (eng != null) {
+              score = score * (1 + (eng - 0.5) * (opts.engagementWeight ?? 0));
             }
           }
           return { episode: ep, score };
@@ -520490,7 +520740,10 @@ var init_selfModel = __esm({
           stats,
           calibration: this.tracker.compute(),
           approachingDecay: this.approachingDecay(),
-          blindSpots: this.blindSpots()
+          blindSpots: this.blindSpots(),
+          // MEM_GAP B1: metaKnowledge always present (the agent introspecting
+          // about its knowledge patterns is core, not optional).
+          metaKnowledge: this.metaKnowledge()
         };
         if (this.opts.predictionStore) {
           const ps = this.opts.predictionStore;
@@ -520507,6 +520760,21 @@ var init_selfModel = __esm({
         }
         return report2;
       }
+      /** MEM_GAP B1: compute metaKnowledge from base stores. */
+      metaKnowledge(opts = {}) {
+        const k = opts.topK ?? 10;
+        return {
+          mostRetrievedTopics: this.queryEpisodeTopics(`SELECT id, content, COALESCE(strength, 1) AS score FROM episodes ORDER BY score DESC LIMIT ?`, k),
+          leastRetrievedTopics: this.queryEpisodeTopics(`SELECT id, content, COALESCE(strength, 1) AS score
+           FROM episodes
+          WHERE importance >= ?
+          ORDER BY score ASC LIMIT ?`, k, [4]),
+          mostValuableMemories: this.queryEpisodeTopics(`SELECT id, content, (importance * COALESCE(strength, 1)) AS score
+           FROM episodes ORDER BY score DESC LIMIT ?`, k),
+          mostUsefulProceduralMemories: this.queryProceduralTopics(k),
+          learningTrajectory: this.computeLearningTrajectory()
+        };
+      }
       // ── private helpers ────────────────────────────────────────────────────────
       scalarCount(sql) {
         try {
@@ -520578,12 +520846,76 @@ var init_selfModel = __esm({
           return [];
         }
       }
+      /** B1 helper: run a query expected to return rows of {id, content, score}
+       *  and convert to MetaKnowledgeTopic[]. Tolerates missing tables. */
+      queryEpisodeTopics(sql, k, prefixArgs = []) {
+        try {
+          const rows = this.db.prepare(sql).all(...prefixArgs, k);
+          return rows.map((r2) => ({
+            id: r2.id,
+            label: (r2.content ?? "").slice(0, 80),
+            score: typeof r2.score === "number" ? r2.score : 0
+          }));
+        } catch {
+          return [];
+        }
+      }
+      /** B1 helper: top-K procedural memories by utility × confidence,
+       *  filtered to active (non-soft-deleted) rows. */
+      queryProceduralTopics(k) {
+        try {
+          const rows = this.db.prepare(`SELECT id, content, (COALESCE(utility, 0.5) * COALESCE(confidence, 0.5)) AS score
+           FROM procedural_memory
+          WHERE deleted_at IS NULL
+          ORDER BY score DESC
+          LIMIT ?`).all(k);
+          return rows.map((r2) => ({
+            id: r2.id,
+            label: (r2.content ?? "").slice(0, 80),
+            score: typeof r2.score === "number" ? r2.score : 0
+          }));
+        } catch {
+          return [];
+        }
+      }
+      /** B1 helper: compute time-bucketed counts of episodes added vs forgotten.
+       *  Bucket width: 1 day. Last 7 buckets, oldest first. Forgotten ≈ count
+       *  of soft-deleted procedural rows with updated_at in the bucket window
+       *  (the closest persistent "removed memory" signal we have). */
+      computeLearningTrajectory() {
+        const buckets = [];
+        const dayMs = 24 * 60 * 60 * 1e3;
+        const now = Date.now();
+        for (let i2 = 6; i2 >= 0; i2--) {
+          const start2 = now - (i2 + 1) * dayMs;
+          const end = now - i2 * dayMs;
+          let added = 0;
+          let forgotten = 0;
+          try {
+            const r2 = this.db.prepare(`SELECT COUNT(*) AS c FROM episodes WHERE timestamp >= ? AND timestamp < ?`).get(start2, end);
+            added = r2?.c ?? 0;
+          } catch {
+          }
+          try {
+            const startIso = new Date(start2).toISOString();
+            const endIso = new Date(end).toISOString();
+            const r2 = this.db.prepare(`SELECT COUNT(*) AS c FROM procedural_memory
+              WHERE deleted_at IS NOT NULL
+                AND updated_at >= ?
+                AND updated_at < ?`).get(startIso, endIso);
+            forgotten = r2?.c ?? 0;
+          } catch {
+          }
+          buckets.push({ bucketStart: start2, bucketWidthMs: dayMs, added, forgotten });
+        }
+        return buckets;
+      }
     };
   }
 });
 
 // packages/memory/dist/predictionStore.js
-function clamp01(x) {
+function clamp014(x) {
   if (!Number.isFinite(x))
     return 0.5;
   if (x < 0)
@@ -520614,7 +520946,7 @@ function durationError(predicted, actual) {
     return 0;
   const safePred = Math.max(predicted, 50);
   const ratio = Math.abs(predicted - actual) / safePred;
-  return clamp01(ratio);
+  return clamp014(ratio);
 }
 var DEFAULT_AXIS_WEIGHTS, PredictionStore;
 var init_predictionStore = __esm({
@@ -520640,7 +520972,7 @@ var init_predictionStore = __esm({
       predict(p2) {
         const sanitized = {
           ...p2,
-          predictedConfidence: clamp01(p2.predictedConfidence),
+          predictedConfidence: clamp014(p2.predictedConfidence),
           predictedDuration: p2.predictedDuration != null && Number.isFinite(p2.predictedDuration) ? Math.max(0, p2.predictedDuration) : null
         };
         this.pending.set(p2.correlationId, sanitized);
@@ -520654,14 +520986,14 @@ var init_predictionStore = __esm({
         this.pending.delete(correlationId);
         const actualDuration = observed.actualDuration != null && Number.isFinite(observed.actualDuration) ? Math.max(0, observed.actualDuration) : null;
         const sim = tokenSimilarity(pred.predictedOutcome, observed.actualOutcome);
-        const outcomeErr = clamp01(1 - sim);
+        const outcomeErr = clamp014(1 - sim);
         const successErr = pred.predictedSuccess === observed.actualSuccess ? 0 : 1;
-        const confidenceErr = clamp01(observed.actualSuccess ? 1 - pred.predictedConfidence : pred.predictedConfidence);
+        const confidenceErr = clamp014(observed.actualSuccess ? 1 - pred.predictedConfidence : pred.predictedConfidence);
         const durationErr = durationError(pred.predictedDuration, actualDuration);
         const w = this.axisWeights;
         const total = w.outcome * outcomeErr + w.success * successErr + w.confidence * confidenceErr + w.duration * durationErr;
         const sumWeights = w.outcome + w.success + w.confidence + w.duration;
-        const errorMagnitude = clamp01(sumWeights > 0 ? total / sumWeights : 0);
+        const errorMagnitude = clamp014(sumWeights > 0 ? total / sumWeights : 0);
         const errorByAxis = {
           outcome: outcomeErr,
           success: successErr,
@@ -520679,7 +521011,7 @@ var init_predictionStore = __esm({
           errorByAxis,
           dominantAxis,
           // Learning signal: large errors with high confidence drive bigger updates
-          learningSignal: clamp01(errorMagnitude * (0.5 + 0.5 * pred.predictedConfidence))
+          learningSignal: clamp014(errorMagnitude * (0.5 + 0.5 * pred.predictedConfidence))
         };
         this.history.push(err);
         if (this.history.length > this.capacity) {
@@ -520826,7 +521158,7 @@ var init_predictionStore = __esm({
             errorMagnitude: r2.error_magnitude ?? 0,
             errorByAxis: axes,
             dominantAxis: r2.dominant_axis ?? "outcome",
-            learningSignal: clamp01((r2.error_magnitude ?? 0) * 0.75)
+            learningSignal: clamp014((r2.error_magnitude ?? 0) * 0.75)
           });
         }
       }
@@ -520834,90 +521166,6 @@ var init_predictionStore = __esm({
   }
 });
 
-// packages/memory/dist/embodiedTrace.js
-function clamp2(x, lo, hi) {
-  if (!Number.isFinite(x))
-    return (lo + hi) / 2;
-  if (x < lo)
-    return lo;
-  if (x > hi)
-    return hi;
-  return x;
-}
-function clamp012(x) {
-  return clamp2(x, 0, 1);
-}
-function nonNegative(x) {
-  if (!Number.isFinite(x) || x < 0)
-    return 0;
-  return x;
-}
-function buildTrace(input) {
-  const i2 = input ?? {};
-  const used = nonNegative(i2.contextTokensUsed ?? DEFAULT_TRACE.contextTokensUsed);
-  const max = nonNegative(i2.contextTokensMax ?? DEFAULT_TRACE.contextTokensMax);
-  const derivedLoad = max > 0 ? used / max : 0;
-  const load2 = i2.cognitiveLoad != null ? clamp012(i2.cognitiveLoad) : clamp012(derivedLoad);
-  return {
-    durationMs: nonNegative(i2.durationMs ?? DEFAULT_TRACE.durationMs),
-    hesitationCount: Math.max(0, Math.floor(i2.hesitationCount ?? 0)),
-    retryCount: Math.max(0, Math.floor(i2.retryCount ?? 0)),
-    intensity: clamp012(i2.intensity ?? DEFAULT_TRACE.intensity),
-    visualGist: typeof i2.visualGist === "string" ? i2.visualGist : void 0,
-    auditoryGist: typeof i2.auditoryGist === "string" ? i2.auditoryGist : void 0,
-    screenState: typeof i2.screenState === "string" ? i2.screenState : void 0,
-    confidence: clamp012(i2.confidence ?? DEFAULT_TRACE.confidence),
-    cognitiveLoad: load2,
-    contextTokensUsed: used,
-    contextTokensMax: max,
-    affect: sanitizeEmotionalState(i2.affect ?? NEUTRAL_AFFECT),
-    timeOfDay: clamp2(Math.floor(i2.timeOfDay ?? DEFAULT_TRACE.timeOfDay), 0, 23),
-    sessionDurationMin: nonNegative(i2.sessionDurationMin ?? 0),
-    consecutiveActions: Math.max(0, Math.floor(i2.consecutiveActions ?? 0))
-  };
-}
-function attachTrace(metadata, trace) {
-  return { ...metadata ?? {}, [EMBODIED_KEY]: trace };
-}
-function extractTrace(metadata) {
-  if (!metadata || typeof metadata !== "object")
-    return null;
-  const raw = metadata[EMBODIED_KEY];
-  if (!raw || typeof raw !== "object")
-    return null;
-  return buildTrace(raw);
-}
-function engagementScore(trace) {
-  const alertness = 1 - trace.cognitiveLoad;
-  return clamp012((trace.intensity + alertness + trace.confidence) / 3);
-}
-function wasHesitant(trace, threshold = 0.4) {
-  return trace.hesitationCount >= 2 || trace.retryCount >= 1 || trace.confidence < threshold;
-}
-var NEUTRAL_AFFECT, DEFAULT_TRACE, EMBODIED_KEY;
-var init_embodiedTrace = __esm({
-  "packages/memory/dist/embodiedTrace.js"() {
-    "use strict";
-    init_homeostaticRegulation();
-    NEUTRAL_AFFECT = { valence: 0, arousal: 0 };
-    DEFAULT_TRACE = {
-      durationMs: 0,
-      hesitationCount: 0,
-      retryCount: 0,
-      intensity: 0,
-      confidence: 0.5,
-      cognitiveLoad: 0,
-      contextTokensUsed: 0,
-      contextTokensMax: 0,
-      affect: NEUTRAL_AFFECT,
-      timeOfDay: 0,
-      sessionDurationMin: 0,
-      consecutiveActions: 0
-    };
-    EMBODIED_KEY = "embodiedTrace";
-  }
-});
-
 // packages/memory/dist/sleepConsolidation.js
 function slowWaveReplay(db, options2 = {}) {
   const topK = options2.topK ?? 20;
@@ -520951,6 +521199,21 @@ function slowWaveReplay(db, options2 = {}) {
         WHERE id IN (${placeholders})`).run(safeDelta, start2, ...ids);
   } catch {
   }
+  const integratedNodes = [];
+  if (options2.graph) {
+    for (const id of ids) {
+      try {
+        const referenced = db.prepare(`SELECT 1 FROM kg_edges WHERE source_episode_id = ? LIMIT 1`).get(id);
+        if (!referenced) {
+          const nodeText = `episode:${id}`;
+          const newNodeId = options2.graph.upsertNode({ text: nodeText, nodeType: "event" });
+          if (newNodeId)
+            integratedNodes.push(newNodeId);
+        }
+      } catch {
+      }
+    }
+  }
   return {
     cycle: {
       phase: "slow_wave",
@@ -520960,7 +521223,10 @@ function slowWaveReplay(db, options2 = {}) {
       downscaledEpisodes: [],
       prunedEpisodes: [],
       novelAssociations: [],
-      energyCost: ids.length
+      energyCost: ids.length + integratedNodes.length,
+      compressedEpisodes: [],
+      flaggedHubs: [],
+      integratedNodes
     }
   };
 }
@@ -520981,10 +521247,11 @@ function remDream(db, options2 = {}) {
     return { cycle: emptyCycle("rem", start2) };
   }
   const walkDepth = Math.max(1, options2.walkDepth ?? 3);
+  const minSim = options2.minSimilarity ?? 0.6;
   for (const seed of seedRows) {
-    let temporalNeighbors = [];
+    let candidateRows = [];
     try {
-      temporalNeighbors = db.prepare(`SELECT id FROM episodes
+      candidateRows = db.prepare(`SELECT id, embedding, timestamp AS ts FROM episodes
              WHERE session_id IS (SELECT session_id FROM episodes WHERE id = ?)
                AND id != ?
              ORDER BY timestamp DESC
@@ -520992,10 +521259,58 @@ function remDream(db, options2 = {}) {
     } catch {
       continue;
     }
-    if (temporalNeighbors.length > walkDepth) {
-      const target = temporalNeighbors[walkDepth];
+    if (candidateRows.length === 0)
+      continue;
+    let seedEmb = null;
+    try {
+      seedEmb = db.prepare(`SELECT embedding FROM episodes WHERE id = ?`).get(seed.id)?.embedding ?? null;
+    } catch {
+    }
+    let chosen = null;
+    const seedFloat = toFloat32(seedEmb);
+    if (seedFloat) {
+      const distantCandidates = candidateRows.slice(walkDepth);
+      let bestSim = minSim;
+      let bestId = null;
+      for (const cand of distantCandidates) {
+        const candFloat = toFloat32(cand.embedding);
+        if (!candFloat || candFloat.length !== seedFloat.length)
+          continue;
+        const sim = cosineSim(seedFloat, candFloat);
+        if (sim > bestSim) {
+          bestSim = sim;
+          bestId = cand.id;
+        }
+      }
+      if (bestId) {
+        chosen = { id: bestId, reason: `rem-embedding-similarity:${bestSim.toFixed(3)}` };
+      }
+    }
+    if (!chosen && candidateRows.length > walkDepth) {
+      const target = candidateRows[walkDepth];
       if (target)
-        novel.push({ from: seed.id, to: target.id, reason: "rem-temporal-distance" });
+        chosen = { id: target.id, reason: "rem-temporal-distance" };
+    }
+    if (chosen)
+      novel.push({ from: seed.id, to: chosen.id, reason: chosen.reason });
+  }
+  if (options2.graph && novel.length > 0) {
+    for (const link of novel) {
+      try {
+        const srcId = options2.graph.upsertNode({ text: `episode:${link.from}`, nodeType: "event" });
+        const dstId = options2.graph.upsertNode({ text: `episode:${link.to}`, nodeType: "event" });
+        if (srcId && dstId) {
+          options2.graph.addEdge({
+            srcId,
+            dstId,
+            relation: "associated_via_rem",
+            edgeType: "associative",
+            confidence: 0.4,
+            sourceEpisodeId: link.from
+          });
+        }
+      } catch {
+      }
     }
   }
   return {
@@ -521007,7 +521322,10 @@ function remDream(db, options2 = {}) {
       downscaledEpisodes: [],
       prunedEpisodes: [],
       novelAssociations: novel,
-      energyCost: seedRows.length + novel.length
+      energyCost: seedRows.length + novel.length,
+      compressedEpisodes: [],
+      flaggedHubs: [],
+      integratedNodes: []
     }
   };
 }
@@ -521038,32 +521356,78 @@ function lightSleep(db, options2 = {}) {
   } catch {
   }
   const pruned = [];
+  const compressed = [];
+  const compressMode = !!options2.compressInsteadOfPrune;
+  const gistMaxChars = Math.max(20, options2.gistMaxChars ?? 80);
   for (const klass of prunableClasses) {
     const stale = stalePerClass[klass];
     const cutoff = start2 - stale;
+    const remaining = maxPrune - (pruned.length + compressed.length);
+    if (remaining <= 0)
+      break;
     let rows = [];
     try {
-      rows = db.prepare(`SELECT id FROM episodes
+      rows = db.prepare(`SELECT id, content FROM episodes
              WHERE decay_class = ?
                AND importance < ?
                AND timestamp < ?
              ORDER BY timestamp ASC
-             LIMIT ?`).all(klass, pruneImportance, cutoff, maxPrune - pruned.length);
+             LIMIT ?`).all(klass, pruneImportance, cutoff, remaining);
     } catch {
       rows = [];
     }
     if (rows.length === 0)
       continue;
-    const ids = rows.map((r2) => r2.id);
-    try {
-      const placeholders = ids.map(() => "?").join(",");
-      db.prepare(`DELETE FROM episodes WHERE id IN (${placeholders})`).run(...ids);
-      pruned.push(...ids);
-    } catch {
+    if (compressMode) {
+      try {
+        const updateStmt = db.prepare(`UPDATE episodes
+              SET content = ?,
+                  metadata = json_patch(COALESCE(metadata, '{}'), json_object('compressedAt', ?))
+            WHERE id = ?`);
+        for (const row of rows) {
+          const truncated = (row.content ?? "").slice(0, gistMaxChars);
+          const gist = (row.content ?? "").length > gistMaxChars ? truncated + "…" : truncated;
+          try {
+            updateStmt.run(gist, start2, row.id);
+            compressed.push(row.id);
+          } catch {
+            try {
+              db.prepare(`UPDATE episodes SET content = ? WHERE id = ?`).run(gist, row.id);
+              compressed.push(row.id);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    } else {
+      const ids = rows.map((r2) => r2.id);
+      try {
+        const placeholders = ids.map(() => "?").join(",");
+        db.prepare(`DELETE FROM episodes WHERE id IN (${placeholders})`).run(...ids);
+        pruned.push(...ids);
+      } catch {
+      }
     }
-    if (pruned.length >= maxPrune)
+    if (pruned.length + compressed.length >= maxPrune)
       break;
   }
+  const hubThreshold = Math.max(1, options2.hubThreshold ?? 50);
+  const flaggedHubs = [];
+  try {
+    const rows = db.prepare(`SELECT node_id, edge_count FROM (
+         SELECT src_id AS node_id, COUNT(*) AS edge_count FROM kg_edges GROUP BY src_id
+         UNION ALL
+         SELECT dst_id AS node_id, COUNT(*) AS edge_count FROM kg_edges GROUP BY dst_id
+       )
+       GROUP BY node_id
+       HAVING SUM(edge_count) >= ?
+       ORDER BY SUM(edge_count) DESC
+       LIMIT 50`).all(hubThreshold);
+    for (const r2 of rows)
+      flaggedHubs.push(r2.node_id);
+  } catch {
+  }
   return {
     cycle: {
       phase: "light",
@@ -521073,7 +521437,10 @@ function lightSleep(db, options2 = {}) {
       downscaledEpisodes: downscaled.map((r2) => r2.id),
       prunedEpisodes: pruned,
       novelAssociations: [],
-      energyCost: downscaled.length + pruned.length
+      energyCost: downscaled.length + pruned.length + compressed.length + flaggedHubs.length,
+      compressedEpisodes: compressed,
+      flaggedHubs,
+      integratedNodes: []
     }
   };
 }
@@ -521097,9 +521464,48 @@ function emptyCycle(phase, start2) {
     downscaledEpisodes: [],
     prunedEpisodes: [],
     novelAssociations: [],
-    energyCost: 0
+    energyCost: 0,
+    compressedEpisodes: [],
+    flaggedHubs: [],
+    integratedNodes: []
   };
 }
+function toFloat32(raw) {
+  if (raw == null)
+    return null;
+  if (raw instanceof Float32Array) {
+    return new Float32Array(raw);
+  }
+  if (raw instanceof Uint8Array) {
+    if (raw.byteLength === 0 || raw.byteLength % 4 !== 0)
+      return null;
+    const fresh = new Uint8Array(raw.byteLength);
+    fresh.set(raw);
+    return new Float32Array(fresh.buffer, 0, raw.byteLength / 4);
+  }
+  if (raw instanceof ArrayBuffer) {
+    if (raw.byteLength === 0 || raw.byteLength % 4 !== 0)
+      return null;
+    return new Float32Array(raw.slice(0));
+  }
+  return null;
+}
+function cosineSim(a2, b) {
+  if (a2.length !== b.length || a2.length === 0)
+    return 0;
+  let dot = 0, na = 0, nb = 0;
+  for (let i2 = 0; i2 < a2.length; i2++) {
+    const x = a2[i2];
+    const y = b[i2];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  if (denom === 0)
+    return 0;
+  return dot / denom;
+}
 function episodeCount(db) {
   try {
     const row = db.prepare(`SELECT COUNT(*) AS c FROM episodes`).get();
@@ -521117,7 +521523,7 @@ var init_sleepConsolidation = __esm({
 
 // packages/memory/dist/socialMemory.js
 import { randomUUID as randomUUID11 } from "node:crypto";
-function clamp3(x, lo, hi) {
+function clamp4(x, lo, hi) {
   if (!Number.isFinite(x))
     return (lo + hi) / 2;
   if (x < lo)
@@ -521126,24 +521532,34 @@ function clamp3(x, lo, hi) {
     return hi;
   return x;
 }
-function clamp013(x) {
-  return clamp3(x, 0, 1);
+function clamp015(x) {
+  return clamp4(x, 0, 1);
 }
 function clampSigned(x) {
-  return clamp3(x, -1, 1);
+  return clamp4(x, -1, 1);
 }
 function sanitizeBig5(p2) {
   return {
-    openness: clamp013(p2?.openness ?? NEUTRAL_BIG5.openness),
-    conscientiousness: clamp013(p2?.conscientiousness ?? NEUTRAL_BIG5.conscientiousness),
-    extraversion: clamp013(p2?.extraversion ?? NEUTRAL_BIG5.extraversion),
-    agreeableness: clamp013(p2?.agreeableness ?? NEUTRAL_BIG5.agreeableness),
-    neuroticism: clamp013(p2?.neuroticism ?? NEUTRAL_BIG5.neuroticism)
+    openness: clamp015(p2?.openness ?? NEUTRAL_BIG5.openness),
+    conscientiousness: clamp015(p2?.conscientiousness ?? NEUTRAL_BIG5.conscientiousness),
+    extraversion: clamp015(p2?.extraversion ?? NEUTRAL_BIG5.extraversion),
+    agreeableness: clamp015(p2?.agreeableness ?? NEUTRAL_BIG5.agreeableness),
+    neuroticism: clamp015(p2?.neuroticism ?? NEUTRAL_BIG5.neuroticism)
   };
 }
 function pairKey(a2, b) {
   return a2 <= b ? { lo: a2, hi: b } : { lo: b, hi: a2 };
 }
+function rowToOpinion(row) {
+  return {
+    id: row.id,
+    topic: row.topic,
+    agentId: row.agent_id,
+    opinion: row.opinion,
+    confidence: row.confidence,
+    timestamp: row.timestamp
+  };
+}
 function rowToAgent(row) {
   return {
     id: row.id,
@@ -521226,6 +521642,16 @@ var init_socialMemory = __esm({
         adopted INTEGER NOT NULL DEFAULT 0,
         timestamp INTEGER NOT NULL
       );
+      -- MEM_GAP B6: collective memory — opinions across agents on a topic
+      CREATE TABLE IF NOT EXISTS social_shared_knowledge (
+        id TEXT PRIMARY KEY,
+        topic TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        opinion TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        timestamp INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_shared_topic ON social_shared_knowledge(topic);
       CREATE INDEX IF NOT EXISTS idx_lessons_source ON social_lessons(source_agent);
       CREATE INDEX IF NOT EXISTS idx_rels_agent_a ON social_relationships(agent_a);
       CREATE INDEX IF NOT EXISTS idx_rels_agent_b ON social_relationships(agent_b);
@@ -521237,13 +521663,13 @@ var init_socialMemory = __esm({
         const id = input.id ?? randomUUID11();
         const existing = this.getAgent(id);
         const personality = sanitizeBig5({ ...existing?.personality ?? {}, ...input.personality ?? {} });
-        const trustOverall = clamp013(input.trust?.overall ?? existing?.trust.overall ?? 0.5);
+        const trustOverall = clamp015(input.trust?.overall ?? existing?.trust.overall ?? 0.5);
         const trustByDomain = {
           ...existing?.trust.byDomain ?? {},
           ...input.trust?.byDomain ?? {}
         };
         for (const k of Object.keys(trustByDomain))
-          trustByDomain[k] = clamp013(trustByDomain[k]);
+          trustByDomain[k] = clamp015(trustByDomain[k]);
         const metadata = input.metadata ?? existing?.metadata ?? null;
         if (existing) {
           this.db.prepare(`UPDATE social_agents
@@ -521283,13 +521709,13 @@ var init_socialMemory = __esm({
         const agent = this.getAgent(agentId);
         if (!agent)
           return null;
-        const weight = clamp013(interaction.weight ?? 0.1);
+        const weight = clamp015(interaction.weight ?? 0.1);
         const targetOverall = interaction.positive ? 1 : 0;
-        const newOverall = clamp013(agent.trust.overall + (targetOverall - agent.trust.overall) * weight);
+        const newOverall = clamp015(agent.trust.overall + (targetOverall - agent.trust.overall) * weight);
         const newByDomain = { ...agent.trust.byDomain };
         if (interaction.domain) {
           const cur = newByDomain[interaction.domain] ?? 0.5;
-          newByDomain[interaction.domain] = clamp013(cur + (targetOverall - cur) * weight);
+          newByDomain[interaction.domain] = clamp015(cur + (targetOverall - cur) * weight);
         }
         const now = Date.now();
         this.db.prepare(`UPDATE social_agents
@@ -521319,14 +521745,14 @@ var init_socialMemory = __esm({
           history.push(newEvent);
           if (history.length > 200)
             history.splice(0, history.length - 200);
-          const strength = clamp013(existing.strength + Math.abs(dStrength));
+          const strength = clamp015(existing.strength + Math.abs(dStrength));
           const valence = clampSigned(existing.valence + dValence);
-          const reciprocity = clamp013(existing.reciprocity * 0.95 + 0.05 * 0.5);
+          const reciprocity = clamp015(existing.reciprocity * 0.95 + 0.05 * 0.5);
           this.db.prepare(`UPDATE social_relationships
               SET strength = ?, valence = ?, reciprocity = ?, last_updated = ?, history = ?
             WHERE agent_a = ? AND agent_b = ?`).run(strength, valence, reciprocity, now, JSON.stringify(history), lo, hi);
         } else {
-          const strength = clamp013(Math.abs(dStrength));
+          const strength = clamp015(Math.abs(dStrength));
           const valence = clampSigned(dValence);
           this.db.prepare(`INSERT INTO social_relationships
              (agent_a, agent_b, strength, valence, reciprocity, last_updated, history)
@@ -521349,7 +521775,7 @@ var init_socialMemory = __esm({
       recordLesson(input) {
         const id = randomUUID11();
         const now = Date.now();
-        const conf = clamp013(input.confidence ?? 0.5);
+        const conf = clamp015(input.confidence ?? 0.5);
         const adopted = input.adopted ? 1 : 0;
         this.db.prepare(`INSERT INTO social_lessons (id, source_agent, lesson, confidence, adopted, timestamp)
          VALUES (?, ?, ?, ?, ?, ?)`).run(id, input.sourceAgent, input.lesson, conf, adopted, now);
@@ -521363,6 +521789,47 @@ var init_socialMemory = __esm({
         const rows = sourceAgent ? this.db.prepare(`SELECT * FROM social_lessons WHERE source_agent = ? ORDER BY timestamp DESC`).all(sourceAgent) : this.db.prepare(`SELECT * FROM social_lessons ORDER BY timestamp DESC`).all();
         return rows.map(rowToLesson);
       }
+      // ── MEM_GAP B6: collective memory ────────────────────────────────────────
+      recordOpinion(input) {
+        const id = randomUUID11();
+        const now = Date.now();
+        const conf = clamp015(input.confidence ?? 0.5);
+        this.db.prepare(`INSERT INTO social_shared_knowledge (id, topic, agent_id, opinion, confidence, timestamp)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(id, input.topic, input.agentId, input.opinion, conf, now);
+        return { id, topic: input.topic, agentId: input.agentId, opinion: input.opinion, confidence: conf, timestamp: now };
+      }
+      /**
+       * Compute consensus on a topic. Returns:
+       *  - contributors: count of distinct agents
+       *  - agreementScore: 1 = unanimous, 0 = perfectly split. Scored by the
+       *    largest opinion-cluster's share (Jaccard-style on normalized text).
+       *  - divergence: 1 - agreementScore.
+       */
+      getConsensus(topic) {
+        const rows = this.db.prepare(`SELECT * FROM social_shared_knowledge WHERE topic = ? ORDER BY timestamp DESC`).all(topic);
+        const opinions = rows.map(rowToOpinion);
+        if (opinions.length === 0) {
+          return { contributors: 0, agreementScore: 1, divergence: 0, opinions };
+        }
+        const agents = new Set(opinions.map((o2) => o2.agentId));
+        const buckets = /* @__PURE__ */ new Map();
+        for (const o2 of opinions) {
+          const norm = o2.opinion.toLowerCase().replace(/\s+/g, " ").trim();
+          buckets.set(norm, (buckets.get(norm) ?? 0) + 1);
+        }
+        const top = Math.max(...buckets.values());
+        const agreementScore = top / opinions.length;
+        return {
+          contributors: agents.size,
+          agreementScore,
+          divergence: 1 - agreementScore,
+          opinions
+        };
+      }
+      listOpinions(topic) {
+        const rows = topic ? this.db.prepare(`SELECT * FROM social_shared_knowledge WHERE topic = ? ORDER BY timestamp DESC`).all(topic) : this.db.prepare(`SELECT * FROM social_shared_knowledge ORDER BY timestamp DESC`).all();
+        return rows.map(rowToOpinion);
+      }
     };
   }
 });
@@ -521496,7 +521963,9 @@ __export(dist_exports2, {
   TemporalGraph: () => TemporalGraph,
   ToolPatternStore: () => ToolPatternStore,
   ValidationStore: () => ValidationStore,
+  applyInfluence: () => applyInfluence,
   attachTrace: () => attachTrace,
+  authorityBias: () => authorityBias,
   autoDecayClass: () => autoDecayClass,
   autoImportance: () => autoImportance,
   batchLink: () => batchLink,
@@ -521506,6 +521975,7 @@ __export(dist_exports2, {
   closeDb: () => closeDb,
   compressAndStore: () => compressAndStore,
   compressToGist: () => compressToGist,
+  conformityBias: () => conformityBias,
   congruenceMultiplier: () => congruenceMultiplier,
   cosineSimilarity: () => cosineSimilarity2,
   createCRLMemoryStore: () => createCRLMemoryStore,
@@ -521529,8 +521999,10 @@ __export(dist_exports2, {
   linkEpisode: () => linkEpisode,
   modulateImportance: () => modulateImportance,
   modulateRetrievalScore: () => modulateRetrievalScore,
+  noveltyBias: () => noveltyBias,
   observeEmotionalState: () => observeEmotionalState,
   personalizedPageRank: () => personalizedPageRank,
+  reciprocityBias: () => reciprocityBias,
   remDream: () => remDream,
   resetCRLConfigStore: () => resetCRLConfigStore,
   retrieveByPPR: () => retrieveByPPR,
@@ -521544,6 +522016,7 @@ __export(dist_exports2, {
   splanifoldRmse: () => rmse,
   splanifoldSerialize: () => serialize,
   suggestRegulation: () => suggestRegulation,
+  suggestRegulationActions: () => suggestRegulationActions,
   thresholdsForStage: () => thresholdsForStage,
   tokenSimilarity: () => tokenSimilarity,
   wasHesitant: () => wasHesitant
@@ -521577,6 +522050,7 @@ var init_dist7 = __esm({
     init_socialMemory();
     init_developmentalStage();
     init_memoryStageContext();
+    init_socialInfluence();
   }
 });
 
@@ -526814,6 +527288,39 @@ Respond with your assessment, then take action.`;
           } catch {
           }
         }
+        if (process.env["OA_DISABLE_STAGE_CONTEXT"] !== "1") {
+          try {
+            const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+            if (!this._stageContext) {
+              this._stageContext = new memMod.MemoryStageContext();
+            }
+            const stageCtx = this._stageContext;
+            const totalEpisodes = this._episodeStore ? this._episodeStore.count() : 0;
+            const sessionCount = typeof this._historicalSessionCount === "number" ? this._historicalSessionCount : 0;
+            const recentPredictionError = this._predictionStore ? this._predictionStore.averageError(50) : 1;
+            const snap = stageCtx.refresh({
+              sessionCount,
+              domainCount: 0,
+              recentPredictionError,
+              crossDomainLinks: 0,
+              totalEpisodes,
+              creativeAssociationCount: 0
+            });
+            if (this._episodeStore) {
+              try {
+                this._episodeStore.setZettelConfig?.(stageCtx.toZettelkastenConfig());
+                this._episodeStore.setImportanceFloor?.(stageCtx.importanceFloor());
+              } catch {
+              }
+            }
+            this.emit({
+              type: "status",
+              content: `Memory stage: ${snap.stage} (importanceFloor=${snap.thresholds.importanceFloor}, linkThreshold=${snap.thresholds.linkThreshold})`,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } catch {
+          }
+        }
         const contextComposition = await this.assembleContext(task, context2);
         const systemPrompt = contextComposition.assembled;
         this._contextTree = new ContextTree(`sys-${systemPrompt.length}`, cleanedTask.slice(0, 200));
@@ -527176,6 +527683,43 @@ TASK: ${task}` : task;
                   content: `STAGNATION DETECTED — injected diagnostic mode at turn ${turn} (${signals.variantCount} variants, ${signals.failureSum} failures, ${signals.filesDelta} files in window)`,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
                 });
+                try {
+                  const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                  const hs = this._homeostat;
+                  if (hs) {
+                    const actions = memMod.suggestRegulationActions(hs);
+                    for (const a2 of actions) {
+                      this.emit({
+                        type: "status",
+                        content: `[REGULATION SUGGESTION] ${a2} — homeostat is off-target (current valence=${hs.current.valence.toFixed(2)}, arousal=${hs.current.arousal.toFixed(2)}, streak=${hs.streak})`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                  }
+                  if (this._selfModel && this._episodeStore) {
+                    const sm = this._selfModel;
+                    const report2 = sm.snapshot();
+                    for (const [domain, c9] of Object.entries(report2.calibration.byDomain)) {
+                      if (c9.n >= 5 && c9.confidence - c9.accuracy > 0.2) {
+                        this.emit({
+                          type: "status",
+                          content: `[SELF-MODEL CALIBRATION mid-session] overconfident in '${domain}': stated ${c9.confidence.toFixed(2)} vs actual ${c9.accuracy.toFixed(2)} across ${c9.n} samples — temper next-action confidence in this domain.`,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                      }
+                    }
+                    this._episodeStore.insert({
+                      sessionId: this._sessionId,
+                      modality: "reflection",
+                      toolName: "self_model_snapshot",
+                      content: `mid-session self-report (stagnation @ turn ${turn}): stage=${report2.developmental?.stage ?? "?"} calGap=${report2.calibration.calibrationGap.toFixed(2)} (n=${report2.calibration.sampleCount}) blindSpots=${report2.blindSpots.length}`,
+                      importance: 7,
+                      decayClass: "session",
+                      metadata: { selfReport: report2, stagnationTurn: turn }
+                    });
+                  }
+                } catch {
+                }
               }
             }
           }
@@ -528029,7 +528573,12 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
           if (turn > 0 && turn % 3 === 0 && this._temporalGraph && this._episodeStore) {
             try {
               const taskGoal = this._taskState.goal || cleanedTask.slice(0, 200);
-              const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, { topK: 3 });
+              const _hs = this._homeostat;
+              const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, {
+                topK: 3,
+                currentEmotionalState: _hs?.current,
+                engagementWeight: 0.2
+              });
               if (pprResult.episodes.length > 0) {
                 const memoryLines = pprResult.episodes.map(({ episode, pprScore, matchedNodes }) => `- [${episode.toolName ?? episode.modality}] ${episode.content.slice(0, 120)} (via: ${matchedNodes.slice(0, 2).join(", ")})`);
                 compacted.push({
@@ -528402,6 +528951,15 @@ ${memoryLines.join("\n")}`
                 if (!this._predictionStore) {
                   this._predictionStore = new memMod.PredictionStore({ capacity: 256 });
                   this._toolDurationAvg = /* @__PURE__ */ new Map();
+                  try {
+                    if (this._episodeStore && process.env["OA_DISABLE_PREDICTION_PERSISTENCE"] !== "1") {
+                      this._predictionStore.restore(this._episodeStore.getDb());
+                    }
+                  } catch {
+                  }
+                }
+                if (!this._homeostat) {
+                  this._homeostat = memMod.createHomeostaticState();
                 }
                 const ps = this._predictionStore;
                 const avgs = this._toolDurationAvg;
@@ -529024,9 +529582,63 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                             importance: Math.min(10, 7 + Math.round(err.errorMagnitude * 3)),
                             metadata: { predictionError: { magnitude: err.errorMagnitude, axis: err.dominantAxis } }
                           });
+                          if (process.env["OA_DISABLE_SOCIAL_MEMORY"] !== "1") {
+                            if (!this._socialMemory) {
+                              this._socialMemory = new memMod.SocialMemoryStore(this._episodeStore.getDb());
+                            }
+                            const social = this._socialMemory;
+                            social.recordLesson({
+                              sourceAgent: "self",
+                              lesson: `${err.prediction.action} produced ${err.dominantAxis}-axis prediction error (magnitude ${err.errorMagnitude.toFixed(2)}). Predicted ${err.prediction.predictedSuccess ? "success" : "failure"}; observed ${err.actualSuccess ? "success" : "failure"}.`,
+                              confidence: Math.min(0.95, 0.5 + err.errorMagnitude * 0.5)
+                            });
+                          }
                         } catch {
                         }
                       }
+                      if (process.env["OA_DISABLE_SOCIAL_MEMORY"] !== "1") {
+                        const SUB_AGENT_TOOLS = /* @__PURE__ */ new Set(["sub_agent", "background_run", "priority_delegate", "skill_execute"]);
+                        if (SUB_AGENT_TOOLS.has(tc.name)) {
+                          try {
+                            if (!this._socialMemory) {
+                              this._socialMemory = new memMod.SocialMemoryStore(this._episodeStore.getDb());
+                            }
+                            const social = this._socialMemory;
+                            const otherId = `${tc.name}:${String(tc.arguments?.["agent_id"] ?? tc.arguments?.["name"] ?? tc.arguments?.["target"] ?? "anonymous").slice(0, 60)}`;
+                            social.upsertAgent({ id: otherId, name: otherId, type: "agent" });
+                            social.recordRelationshipEvent("self", otherId, {
+                              event: groundTruthSuccess ? "successful collaboration" : "failed collaboration",
+                              impactOnStrength: 0.05,
+                              impactOnValence: groundTruthSuccess ? 0.1 : -0.1
+                            });
+                          } catch {
+                          }
+                        }
+                      }
+                      if (this._homeostat) {
+                        const ctxUsed = typeof this._lastContextTokens === "number" ? this._lastContextTokens : 0;
+                        const ctxMax = typeof this._contextWindowMax === "number" ? this._contextWindowMax : 0;
+                        const cogLoad = ctxMax > 0 ? Math.max(0, Math.min(1, ctxUsed / ctxMax)) : 0;
+                        let valence = 0;
+                        const verifierDowngrade = v && v.trustworthy === false;
+                        if (verifierDowngrade)
+                          valence -= 0.6;
+                        else if (groundTruthSuccess)
+                          valence += 0.3;
+                        else
+                          valence -= 0.3;
+                        if (err && err.errorMagnitude > 0.5)
+                          valence -= 0.4;
+                        if (valence < -1)
+                          valence = -1;
+                        if (valence > 1)
+                          valence = 1;
+                        const recentFailures = ps ? ps.axisProfile(8).success : 0;
+                        let arousal = Math.max(0, Math.min(1, cogLoad * 0.7 + recentFailures * 0.4));
+                        if (arousal < 0.05)
+                          arousal = 0.05;
+                        this._homeostat = memMod.observeEmotionalState(this._homeostat, { valence, arousal });
+                      }
                     }
                   } catch {
                   }
@@ -530665,6 +531277,89 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
             if (pruned > 0) {
               this.emit({ type: "status", content: `Pruned ${pruned} expired session episodes`, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
             }
+            if (process.env["OA_DISABLE_SELF_MODEL"] !== "1") {
+              try {
+                const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                const tracker = this._confidenceTracker;
+                const ps = this._predictionStore;
+                if (!this._selfModel) {
+                  const db = this._episodeStore.getDb();
+                  this._selfModel = new memMod.SelfModel(db, tracker, {
+                    predictionStore: ps,
+                    // MEM_GAP B7: real metrics from observable corpus state.
+                    metricsBuilder: (stats, prediction) => {
+                      let creativeAssociationCount = 0;
+                      try {
+                        const r2 = db.prepare(`SELECT COUNT(*) AS c FROM episodes WHERE tool_name IN ('rem_association', 'sleep_integration')`).get();
+                        creativeAssociationCount = r2?.c ?? 0;
+                      } catch {
+                      }
+                      let crossDomainLinks = 0;
+                      try {
+                        const r2 = db.prepare(`SELECT COUNT(DISTINCT
+                            substr(src.text, 1, instr(src.text, ':') - 1) || '|' ||
+                            substr(dst.text, 1, instr(dst.text, ':') - 1)
+                          ) AS c
+                          FROM kg_edges e
+                          JOIN kg_nodes src ON src.id = e.src_id
+                          JOIN kg_nodes dst ON dst.id = e.dst_id
+                          WHERE instr(src.text, ':') > 0
+                            AND instr(dst.text, ':') > 0
+                            AND substr(src.text, 1, instr(src.text, ':') - 1) <>
+                                substr(dst.text, 1, instr(dst.text, ':') - 1)`).get();
+                        crossDomainLinks = r2?.c ?? 0;
+                      } catch {
+                      }
+                      let domainCount = 0;
+                      try {
+                        const r2 = db.prepare(`SELECT COUNT(DISTINCT substr(text, 1, instr(text, ':') - 1)) AS c
+                           FROM kg_nodes WHERE instr(text, ':') > 0`).get();
+                        domainCount = r2?.c ?? 0;
+                      } catch {
+                      }
+                      return {
+                        sessionCount: typeof this._historicalSessionCount === "number" ? this._historicalSessionCount : 0,
+                        domainCount,
+                        recentPredictionError: prediction?.averageError ?? 1,
+                        crossDomainLinks,
+                        totalEpisodes: stats.totalEpisodes,
+                        creativeAssociationCount
+                      };
+                    }
+                  });
+                }
+                const sm = this._selfModel;
+                const report2 = sm.snapshot();
+                this._episodeStore.insert({
+                  sessionId: this._sessionId,
+                  modality: "reflection",
+                  toolName: "self_model_snapshot",
+                  content: `Self-report: stage=${report2.developmental?.stage ?? "?"} totalEpisodes=${report2.stats.totalEpisodes} avgImp=${(report2.stats.averageImportance ?? 0).toFixed(2)} calGap=${report2.calibration.calibrationGap.toFixed(2)} (n=${report2.calibration.sampleCount}) approachingDecay=${report2.approachingDecay.session.length}/${report2.approachingDecay.daily.length}/${report2.approachingDecay.procedural.length}`,
+                  importance: 7,
+                  decayClass: "procedural",
+                  metadata: { selfReport: report2 }
+                });
+                for (const [domain, c9] of Object.entries(report2.calibration.byDomain)) {
+                  if (c9.n >= 5 && c9.confidence - c9.accuracy > 0.2) {
+                    this.emit({
+                      type: "status",
+                      content: `[SELF-MODEL CALIBRATION] overconfident in domain '${domain}': stated avg ${c9.confidence.toFixed(2)} vs actual ${c9.accuracy.toFixed(2)} across ${c9.n} samples — temper next-action confidence in this domain.`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                }
+              } catch {
+              }
+            }
+            if (process.env["OA_DISABLE_PREDICTION_PERSISTENCE"] !== "1") {
+              try {
+                const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                const ps = this._predictionStore;
+                if (ps)
+                  ps.snapshot(this._episodeStore.getDb());
+              } catch {
+              }
+            }
             if (process.env["OA_DISABLE_SOCIAL_MEMORY"] !== "1") {
               try {
                 const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
@@ -530693,10 +531388,25 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
             if (process.env["OA_DISABLE_SLEEP_CONSOLIDATION"] !== "1") {
               try {
                 const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                const stageCtx = this._stageContext;
+                const lightTune = stageCtx ? stageCtx.toLightSleepTunables() : {};
                 const cycle = memMod.runConsolidationCycle(this._episodeStore.getDb(), {
-                  light: { prunableClasses: ["session"] }
-                  // never auto-prune daily/permanent
+                  slowWave: this._temporalGraph ? { graph: this._temporalGraph } : {},
+                  rem: this._temporalGraph ? { graph: this._temporalGraph } : {},
+                  light: { prunableClasses: ["session"], ...lightTune }
                 });
+                if (stageCtx) {
+                  const totalEpisodes = this._episodeStore.count();
+                  const recentPredictionError = this._predictionStore ? this._predictionStore.averageError(50) : 1;
+                  stageCtx.refresh({
+                    sessionCount: typeof this._historicalSessionCount === "number" ? this._historicalSessionCount : 0,
+                    domainCount: 0,
+                    recentPredictionError,
+                    crossDomainLinks: 0,
+                    totalEpisodes,
+                    creativeAssociationCount: cycle.rem.novelAssociations.length
+                  });
+                }
                 if (this._temporalGraph && cycle.rem.novelAssociations.length > 0) {
                   try {
                     for (const link of cycle.rem.novelAssociations) {
@@ -577628,7 +578338,7 @@ function appraiseEvent(event) {
       return null;
   }
 }
-function clamp4(value2, min, max) {
+function clamp5(value2, min, max) {
   return Math.max(min, Math.min(max, value2));
 }
 var BASELINE_VALENCE, BASELINE_AROUSAL, DECAY_HALF_LIFE_MS, LABEL_UPDATE_INTERVAL_MS, EXCITEMENT_THRESHOLD, DISTRESS_THRESHOLD, OUTREACH_COOLDOWN_MS, OUTREACH_MIN_STREAK, LABEL_REGEN_THRESHOLD, EmotionEngine;
@@ -577766,8 +578476,8 @@ var init_emotion_engine = __esm({
         if (this.consecutiveFailures >= 2) {
           momentum = 1 + (this.consecutiveFailures - 1) * 0.25;
         }
-        this.state.valence = clamp4(this.state.valence + delta.valence * momentum, -1, 1);
-        this.state.arousal = clamp4(this.state.arousal + delta.arousal * momentum, 0, 1);
+        this.state.valence = clamp5(this.state.valence + delta.valence * momentum, -1, 1);
+        this.state.arousal = clamp5(this.state.arousal + delta.arousal * momentum, 0, 1);
         this.state.updatedAt = Date.now();
         const deterministicLabel = labelFromCoordinates(this.state.valence, this.state.arousal);
         this.state.label = deterministicLabel.label;
@@ -580598,7 +581308,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter11 } from "node:events";
-function clamp014(x) {
+function clamp016(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -580637,9 +581347,9 @@ function computeSignalFromText(text, confidence) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence === "number" && !Number.isNaN(confidence)) {
-    score = 0.7 * score + 0.3 * clamp014(confidence);
+    score = 0.7 * score + 0.3 * clamp016(confidence);
   }
-  return clamp014(score);
+  return clamp016(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -580909,7 +581619,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp014(snr) : computeSignalFromText(text, confidence);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp016(snr) : computeSignalFromText(text, confidence);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);