open-agents-ai 0.187.508 → 0.187.510

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"() {
@@ -520490,7 +520527,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 +520547,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 +520633,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 clamp012(x) {
   if (!Number.isFinite(x))
     return 0.5;
   if (x < 0)
@@ -520614,7 +520733,7 @@ function durationError(predicted, actual) {
     return 0;
   const safePred = Math.max(predicted, 50);
   const ratio = Math.abs(predicted - actual) / safePred;
-  return clamp01(ratio);
+  return clamp012(ratio);
 }
 var DEFAULT_AXIS_WEIGHTS, PredictionStore;
 var init_predictionStore = __esm({
@@ -520640,7 +520759,7 @@ var init_predictionStore = __esm({
       predict(p2) {
         const sanitized = {
           ...p2,
-          predictedConfidence: clamp01(p2.predictedConfidence),
+          predictedConfidence: clamp012(p2.predictedConfidence),
           predictedDuration: p2.predictedDuration != null && Number.isFinite(p2.predictedDuration) ? Math.max(0, p2.predictedDuration) : null
         };
         this.pending.set(p2.correlationId, sanitized);
@@ -520654,14 +520773,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 = clamp012(1 - sim);
         const successErr = pred.predictedSuccess === observed.actualSuccess ? 0 : 1;
-        const confidenceErr = clamp01(observed.actualSuccess ? 1 - pred.predictedConfidence : pred.predictedConfidence);
+        const confidenceErr = clamp012(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 = clamp012(sumWeights > 0 ? total / sumWeights : 0);
         const errorByAxis = {
           outcome: outcomeErr,
           success: successErr,
@@ -520679,7 +520798,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: clamp012(errorMagnitude * (0.5 + 0.5 * pred.predictedConfidence))
         };
         this.history.push(err);
         if (this.history.length > this.capacity) {
@@ -520826,7 +520945,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: clamp012((r2.error_magnitude ?? 0) * 0.75)
           });
         }
       }
@@ -520844,7 +520963,7 @@ function clamp2(x, lo, hi) {
     return hi;
   return x;
 }
-function clamp012(x) {
+function clamp013(x) {
   return clamp2(x, 0, 1);
 }
 function nonNegative(x) {
@@ -520857,16 +520976,16 @@ function buildTrace(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);
+  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: clamp012(i2.intensity ?? DEFAULT_TRACE.intensity),
+    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: clamp012(i2.confidence ?? DEFAULT_TRACE.confidence),
+    confidence: clamp013(i2.confidence ?? DEFAULT_TRACE.confidence),
     cognitiveLoad: load2,
     contextTokensUsed: used,
     contextTokensMax: max,
@@ -520889,7 +521008,7 @@ function extractTrace(metadata) {
 }
 function engagementScore(trace) {
   const alertness = 1 - trace.cognitiveLoad;
-  return clamp012((trace.intensity + alertness + trace.confidence) / 3);
+  return clamp013((trace.intensity + alertness + trace.confidence) / 3);
 }
 function wasHesitant(trace, threshold = 0.4) {
   return trace.hesitationCount >= 2 || trace.retryCount >= 1 || trace.confidence < threshold;
@@ -520951,6 +521070,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 +521094,10 @@ function slowWaveReplay(db, options2 = {}) {
       downscaledEpisodes: [],
       prunedEpisodes: [],
       novelAssociations: [],
-      energyCost: ids.length
+      energyCost: ids.length + integratedNodes.length,
+      compressedEpisodes: [],
+      flaggedHubs: [],
+      integratedNodes
     }
   };
 }
@@ -520998,6 +521135,25 @@ function remDream(db, options2 = {}) {
         novel.push({ from: seed.id, to: target.id, reason: "rem-temporal-distance" });
     }
   }
+  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 {
     cycle: {
       phase: "rem",
@@ -521007,7 +521163,10 @@ function remDream(db, options2 = {}) {
       downscaledEpisodes: [],
       prunedEpisodes: [],
       novelAssociations: novel,
-      energyCost: seedRows.length + novel.length
+      energyCost: seedRows.length + novel.length,
+      compressedEpisodes: [],
+      flaggedHubs: [],
+      integratedNodes: []
     }
   };
 }
@@ -521038,32 +521197,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 +521278,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,7 +521305,10 @@ function emptyCycle(phase, start2) {
     downscaledEpisodes: [],
     prunedEpisodes: [],
     novelAssociations: [],
-    energyCost: 0
+    energyCost: 0,
+    compressedEpisodes: [],
+    flaggedHubs: [],
+    integratedNodes: []
   };
 }
 function episodeCount(db) {
@@ -521126,7 +521337,7 @@ function clamp3(x, lo, hi) {
     return hi;
   return x;
 }
-function clamp013(x) {
+function clamp014(x) {
   return clamp3(x, 0, 1);
 }
 function clampSigned(x) {
@@ -521134,16 +521345,26 @@ function clampSigned(x) {
 }
 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: clamp014(p2?.openness ?? NEUTRAL_BIG5.openness),
+    conscientiousness: clamp014(p2?.conscientiousness ?? NEUTRAL_BIG5.conscientiousness),
+    extraversion: clamp014(p2?.extraversion ?? NEUTRAL_BIG5.extraversion),
+    agreeableness: clamp014(p2?.agreeableness ?? NEUTRAL_BIG5.agreeableness),
+    neuroticism: clamp014(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 +521447,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 +521468,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 = clamp014(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] = clamp014(trustByDomain[k]);
         const metadata = input.metadata ?? existing?.metadata ?? null;
         if (existing) {
           this.db.prepare(`UPDATE social_agents
@@ -521283,13 +521514,13 @@ var init_socialMemory = __esm({
         const agent = this.getAgent(agentId);
         if (!agent)
           return null;
-        const weight = clamp013(interaction.weight ?? 0.1);
+        const weight = clamp014(interaction.weight ?? 0.1);
         const targetOverall = interaction.positive ? 1 : 0;
-        const newOverall = clamp013(agent.trust.overall + (targetOverall - agent.trust.overall) * weight);
+        const newOverall = clamp014(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] = clamp014(cur + (targetOverall - cur) * weight);
         }
         const now = Date.now();
         this.db.prepare(`UPDATE social_agents
@@ -521319,14 +521550,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 = clamp014(existing.strength + Math.abs(dStrength));
           const valence = clampSigned(existing.valence + dValence);
-          const reciprocity = clamp013(existing.reciprocity * 0.95 + 0.05 * 0.5);
+          const reciprocity = clamp014(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 = clamp014(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 +521580,7 @@ var init_socialMemory = __esm({
       recordLesson(input) {
         const id = randomUUID11();
         const now = Date.now();
-        const conf = clamp013(input.confidence ?? 0.5);
+        const conf = clamp014(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 +521594,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 = clamp014(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);
+      }
     };
   }
 });
@@ -521461,6 +521733,64 @@ var init_memoryStageContext = __esm({
   }
 });
 
+// packages/memory/dist/socialInfluence.js
+function clamp4(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function clamp015(x) {
+  return clamp4(x, 0, 1);
+}
+function conformityBias(myConfidence, groupAgreement, memoryAlignsWithGroup, weight = 0.5) {
+  const conf = clamp015(myConfidence);
+  const agree = clamp015(groupAgreement);
+  const w = clamp015(weight);
+  const pull = (agree - 0.5) * 2 * conf * w;
+  return memoryAlignsWithGroup ? 1 + pull : 1 - pull;
+}
+function authorityBias(sourceTrust, weight = 0.4) {
+  const t2 = clamp015(sourceTrust);
+  const w = clamp015(weight);
+  return 1 + (t2 - 0.5) * 2 * w;
+}
+function noveltyBias(memoryDivergence, weight = 0.3) {
+  const d2 = clamp015(memoryDivergence);
+  const w = clamp015(weight);
+  return 1 + d2 * w;
+}
+function reciprocityBias(relationshipStrength, relationshipValence, weight = 0.3) {
+  const s2 = clamp015(relationshipStrength);
+  const v = clamp4(relationshipValence, -1, 1);
+  const w = clamp015(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/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
@@ -521496,7 +521826,9 @@ __export(dist_exports2, {
   TemporalGraph: () => TemporalGraph,
   ToolPatternStore: () => ToolPatternStore,
   ValidationStore: () => ValidationStore,
+  applyInfluence: () => applyInfluence,
   attachTrace: () => attachTrace,
+  authorityBias: () => authorityBias,
   autoDecayClass: () => autoDecayClass,
   autoImportance: () => autoImportance,
   batchLink: () => batchLink,
@@ -521506,6 +521838,7 @@ __export(dist_exports2, {
   closeDb: () => closeDb,
   compressAndStore: () => compressAndStore,
   compressToGist: () => compressToGist,
+  conformityBias: () => conformityBias,
   congruenceMultiplier: () => congruenceMultiplier,
   cosineSimilarity: () => cosineSimilarity2,
   createCRLMemoryStore: () => createCRLMemoryStore,
@@ -521529,8 +521862,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 +521879,7 @@ __export(dist_exports2, {
   splanifoldRmse: () => rmse,
   splanifoldSerialize: () => serialize,
   suggestRegulation: () => suggestRegulation,
+  suggestRegulationActions: () => suggestRegulationActions,
   thresholdsForStage: () => thresholdsForStage,
   tokenSimilarity: () => tokenSimilarity,
   wasHesitant: () => wasHesitant
@@ -521577,6 +521913,7 @@ var init_dist7 = __esm({
     init_socialMemory();
     init_developmentalStage();
     init_memoryStageContext();
+    init_socialInfluence();
   }
 });
 
@@ -523505,13 +523842,7 @@ function checkMutateMtimeDelta(intent, cwd4, ctx3, _result) {
       bestNewest = auxNewest;
   }
   if (bestNewest <= 0) {
-    return {
-      trustworthy: false,
-      syntheticError: `Command (${intent.verb}) reported success but ${cwd4} contains no files. The action either didn't run or had no effect.`,
-      intentBucket: bucket,
-      outcomeClass: "broken",
-      detail: "no files under cwd after mutate intent"
-    };
+    return { trustworthy: true, intentBucket: bucket, outcomeClass: "unknown", detail: "empty cwd — verifier abstaining" };
   }
   if (bestNewest < ctx3.startedAt - MTIME_GRACE_MS) {
     const ageSec = Math.round(((ctx3.now ? ctx3.now() : Date.now()) - bestNewest) / 1e3);
@@ -523918,6 +524249,248 @@ var init_postActionVerifier = __esm({
   }
 });
 
+// packages/orchestrator/dist/errorClusterTracker.js
+var errorClusterTracker_exports = {};
+__export(errorClusterTracker_exports, {
+  ErrorClusterTracker: () => ErrorClusterTracker,
+  parseErrors: () => parseErrors
+});
+function parseErrors(output) {
+  if (!output || typeof output !== "string")
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const { re, build } of ERROR_PATTERNS) {
+    re.lastIndex = 0;
+    let m2;
+    while ((m2 = re.exec(output)) !== null) {
+      const err = build(m2);
+      if (!err)
+        continue;
+      const key = `${err.file}|${err.line ?? ""}|${err.col ?? ""}|${err.code}|${err.message.slice(0, 32)}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      out.push(err);
+    }
+  }
+  return out;
+}
+function clusterKey(scope, file, code8) {
+  return `${scope}\0${file}\0${code8}`;
+}
+function parseClusterKey(key) {
+  const parts = key.split("\0");
+  return { file: parts[1] ?? "", code: parts[2] ?? "" };
+}
+function shortFile(p2) {
+  const parts = p2.split("/");
+  return parts.length <= 2 ? p2 : `…/${parts.slice(-2).join("/")}`;
+}
+function formatStagnantLine(c9, critical) {
+  const codeLabel = c9.key.code ? `× ${c9.key.code}` : "× errors";
+  const tag = critical ? "STAGNANT-CRIT" : "STAGNANT";
+  return `${tag}: ${shortFile(c9.key.file)} ${c9.count}${codeLabel} unchanged across ${c9.attemptsSinceCountChange} attempts — per-line edits aren't converging; consider reverting the affected region or rewriting it as a unit`;
+}
+var ERROR_PATTERNS, DEFAULTS, ErrorClusterTracker;
+var init_errorClusterTracker = __esm({
+  "packages/orchestrator/dist/errorClusterTracker.js"() {
+    "use strict";
+    ERROR_PATTERNS = [
+      // Style A: file:line:col: severity[: code]: message
+      // Matches gcc, clang, eslint, golangci-lint, ruby, generic POSIX tools.
+      {
+        re: /^([^\s:()]+):(\d+):(\d+):\s*(error|warning|note)(?::\s*([A-Za-z][\w/-]*))?\s*:?\s*(.*)$/gm,
+        build: (m2) => {
+          const file = m2[1];
+          if (/^https?:\/\//.test(file))
+            return null;
+          return {
+            file,
+            line: parseInt(m2[2], 10),
+            col: parseInt(m2[3], 10),
+            severity: m2[4],
+            code: (m2[5] ?? "").trim(),
+            message: (m2[6] ?? "").trim().slice(0, 240)
+          };
+        }
+      },
+      // Style B: file(line,col): severity CODE: message  (TypeScript)
+      {
+        re: /^([^\s(]+):?\s*\((\d+),(\d+)\)\s*:?\s*(error|warning|note)\s+([A-Z]+\d+)\s*:\s*(.*)$/gm,
+        build: (m2) => ({
+          file: m2[1],
+          line: parseInt(m2[2], 10),
+          col: parseInt(m2[3], 10),
+          severity: m2[4],
+          code: m2[5],
+          message: (m2[6] ?? "").trim().slice(0, 240)
+        })
+      },
+      // Style C: error[CODE]: message ... --> file:line:col   (Rust-style)
+      {
+        re: /^error(?:\[([A-Z]\d+)\])?:\s*(.+?)\n\s*-->\s*([^\s:]+):(\d+):(\d+)/gms,
+        build: (m2) => ({
+          file: m2[3],
+          line: parseInt(m2[4], 10),
+          col: parseInt(m2[5], 10),
+          severity: "error",
+          code: (m2[1] ?? "").trim(),
+          message: (m2[2] ?? "").trim().slice(0, 240)
+        })
+      },
+      // Style D: FAILED file::test_id [- message]   (pytest, similar)
+      {
+        re: /^FAILED\s+([^\s:]+)::([\w\-.[\]/]+)(?:\s+-\s+(.*))?$/gm,
+        build: (m2) => ({
+          file: m2[1],
+          severity: "error",
+          // Treat the test id as the cluster code so a flapping test stays in
+          // its own bucket, while many distinct tests in the same file each
+          // form their own cluster (more accurate than collapsing all
+          // pytest failures in a file into one).
+          code: m2[2],
+          message: (m2[3] ?? "").trim().slice(0, 240)
+        })
+      }
+    ];
+    DEFAULTS = {
+      warnAttempts: 3,
+      criticalAttempts: 5,
+      cooldownAttempts: 2,
+      maxClusters: 200
+    };
+    ErrorClusterTracker = class {
+      opts;
+      now;
+      clusters = /* @__PURE__ */ new Map();
+      lastEmittedAt = /* @__PURE__ */ new Map();
+      // key → observations counter at last emit
+      observationCounter = 0;
+      constructor(options2 = {}) {
+        this.opts = { ...DEFAULTS, ...options2 };
+        this.now = options2.now ?? Date.now;
+      }
+      /**
+       * Feed a new tool output into the tracker. Returns the changes for this
+       * observation plus a one-line summary suitable for context injection.
+       *
+       * @param output  raw stdout/stderr from the tool
+       * @param toolKey optional caller-supplied scope (e.g. "tsc:/path/to/cwd").
+       *                If two distinct tools emit similar errors in the same
+       *                file but in different scopes, pass distinct keys to
+       *                keep their clusters separate. Default: "" (shared).
+       */
+      observe(output, toolKey = "") {
+        this.observationCounter++;
+        const errors = parseErrors(output);
+        const observedClusters = /* @__PURE__ */ new Map();
+        for (const e2 of errors) {
+          const key = clusterKey(toolKey, e2.file, e2.code);
+          const cur = observedClusters.get(key);
+          if (cur)
+            cur.count += 1;
+          else
+            observedClusters.set(key, { count: 1, sample: e2.message });
+        }
+        const changes = [];
+        const lines = [];
+        let hasCritical = false;
+        const nowMs = this.now();
+        for (const [key, { count, sample }] of observedClusters) {
+          const prior = this.clusters.get(key);
+          if (!prior) {
+            const ck = parseClusterKey(key);
+            const entry = {
+              key: ck,
+              count,
+              sample,
+              observations: 1,
+              attemptsSinceCountChange: 1,
+              lastUpdated: nowMs,
+              previousCount: 0
+            };
+            this.clusters.set(key, entry);
+            changes.push({ kind: "new", cluster: entry });
+            continue;
+          }
+          prior.observations++;
+          prior.lastUpdated = nowMs;
+          prior.sample = sample;
+          if (count === prior.count) {
+            prior.attemptsSinceCountChange++;
+          } else {
+            prior.previousCount = prior.count;
+            prior.count = count;
+            prior.attemptsSinceCountChange = 1;
+          }
+          if (count > prior.previousCount && prior.attemptsSinceCountChange === 1) {
+            changes.push({ kind: "grown", cluster: prior, from: prior.previousCount, to: count });
+            lines.push(`${shortFile(prior.key.file)}: ${prior.previousCount}→${count}× ${prior.key.code || "errors"} (regressed)`);
+          } else if (count < prior.previousCount && prior.attemptsSinceCountChange === 1) {
+            changes.push({ kind: "shrunk", cluster: prior, from: prior.previousCount, to: count });
+            lines.push(`${shortFile(prior.key.file)}: ${prior.previousCount}→${count}× ${prior.key.code || "errors"} (improving)`);
+          } else if (prior.attemptsSinceCountChange >= this.opts.warnAttempts) {
+            if (this.lastEmittedAt.has(key)) {
+              const last2 = this.lastEmittedAt.get(key);
+              const sinceEmit = this.observationCounter - last2;
+              if (sinceEmit < this.opts.cooldownAttempts)
+                continue;
+            }
+            const isCritical = prior.attemptsSinceCountChange >= this.opts.criticalAttempts;
+            if (isCritical)
+              hasCritical = true;
+            changes.push({
+              kind: "stagnant",
+              cluster: prior,
+              attempts: prior.attemptsSinceCountChange,
+              severity: isCritical ? "critical" : "warn"
+            });
+            lines.push(formatStagnantLine(prior, isCritical));
+            this.lastEmittedAt.set(key, this.observationCounter);
+          }
+        }
+        for (const [key, prior] of [...this.clusters]) {
+          if (observedClusters.has(key))
+            continue;
+          if (prior.count > 0 && nowMs - prior.lastUpdated < 6e4) {
+            changes.push({ kind: "resolved", key: prior.key });
+            lines.push(`${shortFile(prior.key.file)}: ${prior.count}× ${prior.key.code || "errors"} → 0 (resolved)`);
+            this.clusters.delete(key);
+            this.lastEmittedAt.delete(key);
+          }
+        }
+        this.evictIfNeeded();
+        return {
+          changes,
+          summaryLine: lines.length === 0 ? "" : `[ERROR CLUSTERS] ${lines.join(" | ").slice(0, 360)}`,
+          hasCritical
+        };
+      }
+      /** Read-only snapshot of currently tracked clusters (defensive copy). */
+      snapshot() {
+        return [...this.clusters.values()].map((c9) => ({ ...c9, key: { ...c9.key } }));
+      }
+      /** Remove all state — useful at session boundaries. */
+      reset() {
+        this.clusters.clear();
+        this.lastEmittedAt.clear();
+        this.observationCounter = 0;
+      }
+      evictIfNeeded() {
+        if (this.clusters.size <= this.opts.maxClusters)
+          return;
+        const sorted = [...this.clusters.entries()].sort((a2, b) => a2[1].lastUpdated - b[1].lastUpdated);
+        const toEvict = sorted.slice(0, this.clusters.size - this.opts.maxClusters);
+        for (const [key] of toEvict) {
+          this.clusters.delete(key);
+          this.lastEmittedAt.delete(key);
+        }
+      }
+    };
+  }
+});
+
 // packages/orchestrator/dist/agenticRunner.js
 import { existsSync as _fsExistsSync, readFileSync as _fsReadFileSync } from "node:fs";
 import { join as _pathJoin } from "node:path";
@@ -526578,6 +527151,32 @@ 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
+            });
+            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));
@@ -528166,6 +528765,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;
@@ -528604,6 +529212,25 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                           toolCallLog[_toolLogTailIdx].intentBucket = _verifierResult.intentBucket;
                           toolCallLog[_toolLogTailIdx].outcomeClass = _verifierResult.outcomeClass;
                         }
+                        if (tc.name === "shell" && (result.output || result.error)) {
+                          try {
+                            const ecMod = await Promise.resolve().then(() => (init_errorClusterTracker(), errorClusterTracker_exports));
+                            if (!this._errorClusterTracker) {
+                              this._errorClusterTracker = new ecMod.ErrorClusterTracker();
+                            }
+                            const tracker = this._errorClusterTracker;
+                            const scope = _verifierResult?.intentBucket ?? "shell";
+                            const obs = tracker.observe(((result.output ?? "") + "\n" + (result.error ?? "")).slice(0, 1e5), scope);
+                            if (obs.summaryLine) {
+                              if (obs.hasCritical) {
+                                messages2.push({ role: "system", content: obs.summaryLine });
+                              } else {
+                                pushSoftInjection("system", obs.summaryLine);
+                              }
+                            }
+                          } catch {
+                          }
+                        }
                         this._hookManager.runPostToolUse(tc.name, finalArgs, (result.output ?? "").slice(0, 2e3), this._sessionId);
                       } catch (err) {
                         result = { success: false, output: "", error: err instanceof Error ? err.message : String(err) };
@@ -528769,9 +529396,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 {
                   }
@@ -530410,6 +531091,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));
@@ -530438,10 +531202,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) {
@@ -577373,7 +578152,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;
@@ -577511,8 +578290,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;
@@ -580343,7 +581122,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) {
@@ -580382,9 +581161,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) + "…";
@@ -580654,7 +581433,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);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.508",
+  "version": "0.187.510",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.508",
+      "version": "0.187.510",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.508",
+  "version": "0.187.510",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",