open-agents-ai 0.187.510 → 0.187.512

package/dist/index.js

@@ -89665,7 +89665,7 @@ var require_auto = __commonJS({
 // ../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash17 } = __require("crypto");
+    var { createHash: createHash20 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -89976,14 +89976,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash17("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash20("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash17("sha256").update(result).digest("base64url");
+          return createHash20("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -232663,7 +232663,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes25, createHash: createHash17 } = __require("crypto");
+    var { randomBytes: randomBytes25, createHash: createHash20 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate2();
@@ -233323,7 +233323,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash20("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -233690,7 +233690,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter13 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash17 } = __require("crypto");
+    var { createHash: createHash20 } = __require("crypto");
     var extension2 = require_extension2();
     var PerMessageDeflate2 = require_permessage_deflate2();
     var subprotocol2 = require_subprotocol();
@@ -233991,7 +233991,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash20("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -246798,13 +246798,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash17 } = await import("node:crypto");
+          const { createHash: createHash20 } = await import("node:crypto");
           const snapshotDir = join27(this.cwd, ".oa", "identity", "snapshots");
           await mkdir6(snapshotDir, { recursive: true });
           const version4 = this.selfState.version;
           const snapshotPath = join27(snapshotDir, `v${version4}.json`);
           await writeFile11(snapshotPath, snapshot, "utf8");
-          const hash = createHash17("sha256").update(snapshot).digest("hex");
+          const hash = createHash20("sha256").update(snapshot).digest("hex");
           await writeFile11(join27(this.cwd, ".oa", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -246937,8 +246937,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash17 } = __require("node:crypto");
-        const machineId = createHash17("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash20 } = __require("node:crypto");
+        const machineId = createHash20("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `oa-${machineId}`,
           version: 1,
@@ -247020,9 +247020,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash17 } = await import("node:crypto");
+            const { createHash: createHash20 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash17("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash20("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join27(this.cwd, ".oa", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -516798,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")
@@ -516994,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);
@@ -517025,6 +517183,8 @@ var init_pprRetrieval = __esm({
     "use strict";
     init_zettelkasten();
     init_homeostaticRegulation();
+    init_socialInfluence();
+    init_embodiedTrace();
     DEFAULT_CONFIG4 = {
       damping: 0.5,
       maxIterations: 50,
@@ -517050,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;
@@ -517118,6 +517300,7 @@ var init_episodeStore = __esm({
     init_db();
     init_zettelkasten();
     init_homeostaticRegulation();
+    init_socialInfluence();
     init_pprRetrieval();
     DECAY_TAU = {
       session: 36e5,
@@ -517139,6 +517322,38 @@ 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;
+      }
+      /** MEM_PATH item #2: bump reuse_count for an episode. Called by the
+       *  orchestrator when an episode that was retrieved is detected to have
+       *  been mentioned in a subsequent assistant turn. Idempotent on missing
+       *  ids (no row → no-op). Returns the new count, or null if not found. */
+      bumpReuseCount(id, delta = 1) {
+        const safeDelta = Number.isFinite(delta) ? delta : 1;
+        try {
+          const result = this.db.prepare(`UPDATE episodes SET reuse_count = COALESCE(reuse_count, 0) + ? WHERE id = ?`).run(safeDelta, id);
+          if (result.changes === 0)
+            return null;
+          const row = this.db.prepare(`SELECT reuse_count FROM episodes WHERE id = ?`).get(id);
+          return row?.reuse_count ?? null;
+        } catch {
+          return null;
+        }
+      }
       constructor(dbPath, graph, zettelConfig) {
         const dir = dbPath === ":memory:" ? null : join75(dbPath, "..");
         if (dir && !existsSync59(dir))
@@ -517178,6 +517393,10 @@ var init_episodeStore = __esm({
           this.db.exec(`ALTER TABLE episodes ADD COLUMN clip_embedding BLOB`);
         } catch {
         }
+        try {
+          this.db.exec(`ALTER TABLE episodes ADD COLUMN reuse_count INTEGER DEFAULT 0`);
+        } catch {
+        }
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("synchronous = NORMAL");
       }
@@ -517190,6 +517409,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)
@@ -517314,7 +517536,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 };
@@ -517429,7 +517662,8 @@ var init_episodeStore = __esm({
           lastRetrieved: row.last_retrieved,
           clipEmbedding: row.clip_embedding ? new Float32Array(new Uint8Array(row.clip_embedding).buffer) : null,
           gist: row.gist,
-          sourceEpisodeId: row.source_episode_id
+          sourceEpisodeId: row.source_episode_id,
+          reuseCount: typeof row.reuse_count === "number" ? row.reuse_count : 0
         };
       }
     };
@@ -520702,7 +520936,7 @@ var init_selfModel = __esm({
 });
 
 // packages/memory/dist/predictionStore.js
-function clamp012(x) {
+function clamp014(x) {
   if (!Number.isFinite(x))
     return 0.5;
   if (x < 0)
@@ -520733,7 +520967,7 @@ function durationError(predicted, actual) {
     return 0;
   const safePred = Math.max(predicted, 50);
   const ratio = Math.abs(predicted - actual) / safePred;
-  return clamp012(ratio);
+  return clamp014(ratio);
 }
 var DEFAULT_AXIS_WEIGHTS, PredictionStore;
 var init_predictionStore = __esm({
@@ -520759,7 +520993,7 @@ var init_predictionStore = __esm({
       predict(p2) {
         const sanitized = {
           ...p2,
-          predictedConfidence: clamp012(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);
@@ -520773,14 +521007,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 = clamp012(1 - sim);
+        const outcomeErr = clamp014(1 - sim);
         const successErr = pred.predictedSuccess === observed.actualSuccess ? 0 : 1;
-        const confidenceErr = clamp012(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 = clamp012(sumWeights > 0 ? total / sumWeights : 0);
+        const errorMagnitude = clamp014(sumWeights > 0 ? total / sumWeights : 0);
         const errorByAxis = {
           outcome: outcomeErr,
           success: successErr,
@@ -520798,7 +521032,7 @@ var init_predictionStore = __esm({
           errorByAxis,
           dominantAxis,
           // Learning signal: large errors with high confidence drive bigger updates
-          learningSignal: clamp012(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) {
@@ -520945,7 +521179,7 @@ var init_predictionStore = __esm({
             errorMagnitude: r2.error_magnitude ?? 0,
             errorByAxis: axes,
             dominantAxis: r2.dominant_axis ?? "outcome",
-            learningSignal: clamp012((r2.error_magnitude ?? 0) * 0.75)
+            learningSignal: clamp014((r2.error_magnitude ?? 0) * 0.75)
           });
         }
       }
@@ -520953,90 +521187,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 clamp013(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 ? 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: 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 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/sleepConsolidation.js
 function slowWaveReplay(db, options2 = {}) {
   const topK = options2.topK ?? 20;
@@ -521118,10 +521268,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
@@ -521129,11 +521280,40 @@ 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) {
@@ -521196,6 +521376,27 @@ function lightSleep(db, options2 = {}) {
     }
   } catch {
   }
+  const promotedToDaily = [];
+  const promotedToProcedural = [];
+  try {
+    const sessionPromos = db.prepare(`SELECT id FROM episodes WHERE decay_class = 'session' AND COALESCE(reuse_count, 0) >= 3 LIMIT 200`).all();
+    for (const r2 of sessionPromos) {
+      try {
+        db.prepare(`UPDATE episodes SET decay_class = 'daily' WHERE id = ?`).run(r2.id);
+        promotedToDaily.push(r2.id);
+      } catch {
+      }
+    }
+    const dailyPromos = db.prepare(`SELECT id FROM episodes WHERE decay_class = 'daily' AND COALESCE(reuse_count, 0) >= 8 LIMIT 200`).all();
+    for (const r2 of dailyPromos) {
+      try {
+        db.prepare(`UPDATE episodes SET decay_class = 'procedural' WHERE id = ?`).run(r2.id);
+        promotedToProcedural.push(r2.id);
+      } catch {
+      }
+    }
+  } catch {
+  }
   const pruned = [];
   const compressed = [];
   const compressMode = !!options2.compressInsteadOfPrune;
@@ -521278,10 +521479,12 @@ function lightSleep(db, options2 = {}) {
       downscaledEpisodes: downscaled.map((r2) => r2.id),
       prunedEpisodes: pruned,
       novelAssociations: [],
-      energyCost: downscaled.length + pruned.length + compressed.length + flaggedHubs.length,
+      energyCost: downscaled.length + pruned.length + compressed.length + flaggedHubs.length + promotedToDaily.length + promotedToProcedural.length,
       compressedEpisodes: compressed,
       flaggedHubs,
-      integratedNodes: []
+      integratedNodes: [],
+      promotedToDaily,
+      promotedToProcedural
     }
   };
 }
@@ -521311,6 +521514,42 @@ function emptyCycle(phase, start2) {
     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();
@@ -521328,7 +521567,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)
@@ -521337,19 +521576,19 @@ function clamp3(x, lo, hi) {
     return hi;
   return x;
 }
-function clamp014(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: 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)
+    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) {
@@ -521468,13 +521707,13 @@ var init_socialMemory = __esm({
         const id = input.id ?? randomUUID11();
         const existing = this.getAgent(id);
         const personality = sanitizeBig5({ ...existing?.personality ?? {}, ...input.personality ?? {} });
-        const trustOverall = clamp014(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] = clamp014(trustByDomain[k]);
+          trustByDomain[k] = clamp015(trustByDomain[k]);
         const metadata = input.metadata ?? existing?.metadata ?? null;
         if (existing) {
           this.db.prepare(`UPDATE social_agents
@@ -521514,13 +521753,13 @@ var init_socialMemory = __esm({
         const agent = this.getAgent(agentId);
         if (!agent)
           return null;
-        const weight = clamp014(interaction.weight ?? 0.1);
+        const weight = clamp015(interaction.weight ?? 0.1);
         const targetOverall = interaction.positive ? 1 : 0;
-        const newOverall = clamp014(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] = clamp014(cur + (targetOverall - cur) * weight);
+          newByDomain[interaction.domain] = clamp015(cur + (targetOverall - cur) * weight);
         }
         const now = Date.now();
         this.db.prepare(`UPDATE social_agents
@@ -521550,14 +521789,14 @@ var init_socialMemory = __esm({
           history.push(newEvent);
           if (history.length > 200)
             history.splice(0, history.length - 200);
-          const strength = clamp014(existing.strength + Math.abs(dStrength));
+          const strength = clamp015(existing.strength + Math.abs(dStrength));
           const valence = clampSigned(existing.valence + dValence);
-          const reciprocity = clamp014(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 = clamp014(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)
@@ -521580,7 +521819,7 @@ var init_socialMemory = __esm({
       recordLesson(input) {
         const id = randomUUID11();
         const now = Date.now();
-        const conf = clamp014(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);
@@ -521598,7 +521837,7 @@ var init_socialMemory = __esm({
       recordOpinion(input) {
         const id = randomUUID11();
         const now = Date.now();
-        const conf = clamp014(input.confidence ?? 0.5);
+        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 };
@@ -521733,60 +521972,564 @@ 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;
+// packages/memory/dist/sessionGist.js
+import { createHash as createHash9 } from "node:crypto";
+function inferDomain(input) {
+  const blob = [
+    input.goal,
+    input.workingDirectory ?? "",
+    input.topToolNames.join(" "),
+    input.topErrorPatterns.join(" ")
+  ].join(" ").toLowerCase();
+  const scores = {};
+  for (const [domain, kws] of Object.entries(DOMAIN_KEYWORDS)) {
+    let s2 = 0;
+    for (const kw of kws)
+      if (blob.includes(kw))
+        s2++;
+    if (s2 > 0)
+      scores[domain] = s2;
+  }
+  const ranked = Object.entries(scores).sort((a2, b) => b[1] - a2[1]);
+  if (ranked.length === 0)
+    return "general";
+  if (ranked.length >= 2 && ranked[0][1] === ranked[1][1])
+    return "mixed";
+  return ranked[0][0];
 }
-function clamp015(x) {
-  return clamp4(x, 0, 1);
+function computeGoalHash(goal) {
+  return createHash9("sha256").update(goal.trim().toLowerCase()).digest("hex").slice(0, 16);
 }
-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 clip(text, n2) {
+  if (!text)
+    return "";
+  const t2 = text.replace(/\s+/g, " ").trim();
+  return t2.length <= n2 ? t2 : t2.slice(0, Math.max(0, n2 - 1)) + "…";
+}
+function buildGist(input) {
+  const goalHash = computeGoalHash(input.goal);
+  const domain = inferDomain(input);
+  const goalClip = clip(input.goal, 60);
+  const tools = input.topToolNames.slice(0, 3).join("/") || "none";
+  const errs = input.topErrorPatterns.slice(0, 3).join(",") || "none";
+  const learned = clip(input.whatWorked[0] ?? "", 60);
+  const durMin = Math.round(input.durationMs / 6e4);
+  const status = input.finalStatus;
+  const parts = [
+    `Session goal=${goalClip}`,
+    `domain=${domain}`,
+    `${input.toolCallCount}x tools (${tools})`,
+    `${input.errorCount}x errs`,
+    `pain=${errs}`,
+    `${durMin}min`,
+    `outcome=${status}`,
+    `learned=${learned || "none"}`
+  ];
+  let content = parts.join("; ");
+  if (content.length > 280)
+    content = content.slice(0, 279) + "…";
+  return {
+    content,
+    goalHash,
+    metadata: {
+      kind: "session_gist",
+      domain,
+      toolCount: input.toolCallCount,
+      errorCount: input.errorCount,
+      finalStatus: input.finalStatus,
+      durationMs: input.durationMs,
+      goalHash
+    }
+  };
 }
-function authorityBias(sourceTrust, weight = 0.4) {
-  const t2 = clamp015(sourceTrust);
-  const w = clamp015(weight);
-  return 1 + (t2 - 0.5) * 2 * w;
+function goalHashOf(goal) {
+  return computeGoalHash(goal);
 }
-function noveltyBias(memoryDivergence, weight = 0.3) {
-  const d2 = clamp015(memoryDivergence);
-  const w = clamp015(weight);
-  return 1 + d2 * w;
+function isSessionGist(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return false;
+  const m2 = metadata;
+  return m2["kind"] === "session_gist" && typeof m2["goalHash"] === "string";
 }
-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;
+var DOMAIN_KEYWORDS;
+var init_sessionGist = __esm({
+  "packages/memory/dist/sessionGist.js"() {
+    "use strict";
+    DOMAIN_KEYWORDS = {
+      typescript: ["tsc", "typescript", ".ts", ".tsx", "vitest", "jest"],
+      node: ["npm", "pnpm", "yarn", "node_modules", "package.json", "node "],
+      python: ["python", ".py", "pytest", "pip ", "poetry", "uv "],
+      golang: [" go ", "go test", "go build", "go.mod"],
+      rust: ["cargo", "rustc", ".rs", "rust "],
+      shell: ["bash", "shell", "/bin/", "curl", "grep"],
+      docs: ["readme", ".md", "markdown", "doc"],
+      threejs: ["three.js", "three ", "webgl", "shader"]
+    };
+  }
+});
+
+// packages/memory/dist/selfTrust.js
+function inferDomainFromEpisode(ep) {
+  const md = ep.metadata && typeof ep.metadata === "object" ? ep.metadata : null;
+  if (md && typeof md["domain"] === "string" && md["domain"])
+    return md["domain"];
+  const blob = [ep.toolName ?? "", ep.content ?? ""].join(" ").toLowerCase();
+  if (!blob.trim())
+    return "general";
+  let best = null;
+  for (const [name10, kws] of Object.entries(DOMAIN_KEYWORDS2)) {
+    let s2 = 0;
+    for (const kw of kws)
+      if (blob.includes(kw))
+        s2++;
+    if (s2 > 0 && (!best || s2 > best.score))
+      best = { name: name10, score: s2 };
+  }
+  return best?.name ?? "general";
+}
+function selfTrustFor(domain, calibration) {
+  if (!domain || !calibration || !calibration.byDomain)
+    return 0.7;
+  const d2 = calibration.byDomain[domain];
+  if (!d2 || d2.n < 3)
+    return 0.7;
+  const overconfBy = d2.confidence - d2.accuracy;
+  if (overconfBy >= 0.3)
+    return 0.4;
+  return 1;
+}
+function buildSelfTrustInfluence(calibration) {
+  if (!calibration)
+    return null;
+  return (ep) => {
+    const domain = inferDomainFromEpisode(ep);
+    const trust = selfTrustFor(domain, calibration);
+    return { sourceTrust: trust };
+  };
 }
-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);
+var DOMAIN_KEYWORDS2;
+var init_selfTrust = __esm({
+  "packages/memory/dist/selfTrust.js"() {
+    "use strict";
+    DOMAIN_KEYWORDS2 = {
+      typescript: ["tsc", "typescript", ".ts", ".tsx", "vitest", "jest"],
+      node: ["npm", "pnpm", "yarn", "node_modules", "package.json", "node "],
+      python: ["python", ".py", "pytest", "pip ", "poetry"],
+      golang: [" go ", "go test", "go build", "go.mod"],
+      rust: ["cargo", "rustc", ".rs"],
+      shell: ["bash", "shell", "/bin/", "curl"],
+      docs: ["readme", ".md", "markdown"],
+      threejs: ["three.js", "webgl", "shader"]
+    };
   }
-  if (ctx3.sourceTrust != null) {
-    m2 *= authorityBias(ctx3.sourceTrust, ctx3.weights?.authority);
+});
+
+// packages/memory/dist/toolOutcomes.js
+var MAX_PER_KEY, DEFAULT_WINDOW_MS, ToolOutcomeTracker;
+var init_toolOutcomes = __esm({
+  "packages/memory/dist/toolOutcomes.js"() {
+    "use strict";
+    MAX_PER_KEY = 500;
+    DEFAULT_WINDOW_MS = 6 * 60 * 60 * 1e3;
+    ToolOutcomeTracker = class {
+      byKey = /* @__PURE__ */ new Map();
+      key(tool, domain) {
+        return `${tool}::${domain}`;
+      }
+      /** Append an outcome. Trims to MAX_PER_KEY (oldest dropped). */
+      record(o2) {
+        const k = this.key(o2.tool, o2.domain);
+        const arr = this.byKey.get(k) ?? [];
+        arr.push(o2);
+        if (arr.length > MAX_PER_KEY)
+          arr.splice(0, arr.length - MAX_PER_KEY);
+        this.byKey.set(k, arr);
+      }
+      /**
+       * Recent success rate for (tool, domain) within `windowMs`. Returns
+       * null when fewer than `minSamples` recent outcomes (default 5) —
+       * caller treats null as "insufficient data, skip forecasting".
+       */
+      recentRate(tool, domain, windowMs = DEFAULT_WINDOW_MS, minSamples = 5) {
+        const arr = this.byKey.get(this.key(tool, domain));
+        if (!arr || arr.length === 0)
+          return null;
+        const cutoff = Date.now() - windowMs;
+        let n2 = 0, succ = 0;
+        for (const o2 of arr) {
+          if (o2.ts >= cutoff) {
+            n2++;
+            if (o2.success)
+              succ++;
+          }
+        }
+        if (n2 < minSamples)
+          return null;
+        return { n: n2, rate: succ / n2 };
+      }
+      /**
+       * All-time stats. Returns rate even with low n (caller decides).
+       * If domain is omitted, aggregates across all domains for that tool.
+       */
+      stats(tool, domain) {
+        let n2 = 0, succ = 0;
+        if (domain) {
+          const arr = this.byKey.get(this.key(tool, domain)) ?? [];
+          for (const o2 of arr) {
+            n2++;
+            if (o2.success)
+              succ++;
+          }
+        } else {
+          for (const [k, arr] of this.byKey.entries()) {
+            if (!k.startsWith(tool + "::"))
+              continue;
+            for (const o2 of arr) {
+              n2++;
+              if (o2.success)
+                succ++;
+            }
+          }
+        }
+        return { n: n2, rate: n2 === 0 ? 0 : succ / n2 };
+      }
+      /** Total outcomes recorded across all keys. */
+      size() {
+        let n2 = 0;
+        for (const arr of this.byKey.values())
+          n2 += arr.length;
+        return n2;
+      }
+      /** Reset (e.g., on session start before restoring from store). */
+      clear() {
+        this.byKey.clear();
+      }
+    };
   }
-  if (ctx3.memoryDivergence != null) {
-    m2 *= noveltyBias(ctx3.memoryDivergence, ctx3.weights?.novelty);
+});
+
+// packages/memory/dist/stagnationRecipes.js
+import { createHash as createHash10 } from "node:crypto";
+function fingerprintSignature(fp) {
+  const normClusters = (fp.errorClusters ?? []).map((s2) => (s2 || "").toLowerCase().replace(/[0-9]+/g, "N").replace(/\s+/g, " ").trim()).filter(Boolean).sort();
+  const tool = (fp.stuckTool ?? "").toLowerCase().trim();
+  const blob = `tool=${tool};clusters=${normClusters.join("|")}`;
+  return createHash10("sha256").update(blob).digest("hex").slice(0, 16);
+}
+function crystallize(store2, input) {
+  const sig = fingerprintSignature(input.fingerprint);
+  const content = [
+    `When stuck on ${(input.fingerprint.errorClusters[0] || "<unknown>").slice(0, 60)}`,
+    input.fingerprint.stuckTool ? `with tool=${input.fingerprint.stuckTool}` : "",
+    input.toolShift ? `, switching ${input.toolShift.from}→${input.toolShift.to}` : "",
+    ` worked: ${input.whatWorked.slice(0, 100)}`
+  ].filter(Boolean).join(" ");
+  return store2.insert({
+    modality: "reflection",
+    toolName: "stagnation_recipe",
+    content,
+    importance: 8,
+    decayClass: "procedural",
+    metadata: {
+      kind: "stagnation_recipe",
+      signature: sig,
+      errorClusters: input.fingerprint.errorClusters.slice(0, 3),
+      stuckTool: input.fingerprint.stuckTool ?? null,
+      toolShift: input.toolShift ?? null
+    }
+  });
+}
+function lookupBySignature(store2, signature, limit = 3) {
+  const lim = Math.max(1, Math.min(20, limit));
+  try {
+    const db = store2.getDb();
+    const rows = db.prepare(`SELECT id, content, metadata, timestamp FROM episodes
+           WHERE tool_name = 'stagnation_recipe'
+           ORDER BY timestamp DESC
+           LIMIT 200`).all();
+    const out = [];
+    for (const r2 of rows) {
+      try {
+        const m2 = r2.metadata ? JSON.parse(r2.metadata) : null;
+        if (m2 && m2.signature === signature) {
+          out.push({ id: r2.id, content: r2.content, signature: m2.signature, ts: r2.timestamp });
+          if (out.length >= lim)
+            break;
+        }
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
   }
-  if (ctx3.relationshipStrength != null && ctx3.relationshipValence != null) {
-    m2 *= reciprocityBias(ctx3.relationshipStrength, ctx3.relationshipValence, ctx3.weights?.reciprocity);
+}
+var init_stagnationRecipes = __esm({
+  "packages/memory/dist/stagnationRecipes.js"() {
+    "use strict";
   }
-  return baseScore * m2;
+});
+
+// packages/memory/dist/codebaseMap.js
+import { createHash as createHash11, randomUUID as randomUUID12 } from "node:crypto";
+function freshNodeId() {
+  return randomUUID12();
 }
-var init_socialInfluence = __esm({
-  "packages/memory/dist/socialInfluence.js"() {
+var CodebaseMap;
+var init_codebaseMap = __esm({
+  "packages/memory/dist/codebaseMap.js"() {
+    "use strict";
+    CodebaseMap = class {
+      db;
+      repoFp;
+      touchCount = /* @__PURE__ */ new Map();
+      constructor(db, repoRoot, commitSha) {
+        this.db = db;
+        this.repoFp = createHash11("sha256").update(`${repoRoot}::${commitSha ?? "no-commit"}`).digest("hex").slice(0, 16);
+        this.ensureSchema();
+      }
+      ensureSchema() {
+        try {
+          this.db.exec(`
+        CREATE TABLE IF NOT EXISTS codebase_map_node (
+          id TEXT PRIMARY KEY,
+          repo_fp TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          path TEXT NOT NULL,
+          last_touched_ts INTEGER,
+          last_result TEXT,
+          metadata TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_cmnode_fp ON codebase_map_node(repo_fp);
+        CREATE INDEX IF NOT EXISTS idx_cmnode_path ON codebase_map_node(path);
+        CREATE TABLE IF NOT EXISTS codebase_map_edge (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          repo_fp TEXT NOT NULL,
+          src_id TEXT NOT NULL,
+          dst_id TEXT NOT NULL,
+          relation TEXT NOT NULL,
+          ts INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_cmedge_fp ON codebase_map_edge(repo_fp);
+      `);
+        } catch {
+        }
+      }
+      fingerprint() {
+        return this.repoFp;
+      }
+      /** Restore in-memory caches. Returns counts for caller status. */
+      restore() {
+        let nodes = 0;
+        let edges = 0;
+        try {
+          const rows = this.db.prepare(`SELECT path FROM codebase_map_node WHERE repo_fp = ?`).all(this.repoFp);
+          nodes = rows.length;
+          for (const r2 of rows) {
+            this.touchCount.set(r2.path, 1);
+          }
+          const erows = this.db.prepare(`SELECT COUNT(*) AS c FROM codebase_map_edge WHERE repo_fp = ?`).get(this.repoFp);
+          edges = erows?.c ?? 0;
+        } catch {
+        }
+        return { nodes, edges };
+      }
+      noteFile(path8, op) {
+        if (!path8)
+          return;
+        this.touchCount.set(path8, (this.touchCount.get(path8) ?? 0) + 1);
+        try {
+          const id = this.idFor("file", path8);
+          const now = Date.now();
+          this.db.prepare(`INSERT INTO codebase_map_node (id, repo_fp, kind, path, last_touched_ts, last_result, metadata)
+         VALUES (?, ?, 'file', ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           last_touched_ts = excluded.last_touched_ts,
+           last_result = excluded.last_result,
+           metadata = excluded.metadata`).run(id, this.repoFp, path8, now, op, JSON.stringify({ op, count: this.touchCount.get(path8) ?? 1 }));
+        } catch {
+        }
+      }
+      noteTest(name10, result) {
+        if (!name10)
+          return;
+        try {
+          const id = this.idFor("test", name10);
+          const now = Date.now();
+          this.db.prepare(`INSERT INTO codebase_map_node (id, repo_fp, kind, path, last_touched_ts, last_result, metadata)
+         VALUES (?, ?, 'test', ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           last_touched_ts = excluded.last_touched_ts,
+           last_result = excluded.last_result,
+           metadata = excluded.metadata`).run(id, this.repoFp, name10, now, result, JSON.stringify({ result }));
+        } catch {
+        }
+      }
+      noteReference(fromPath, toPath) {
+        if (!fromPath || !toPath || fromPath === toPath)
+          return;
+        try {
+          const srcId = this.idFor("file", fromPath);
+          const dstId = this.idFor("file", toPath);
+          const now = Date.now();
+          this.db.prepare(`INSERT INTO codebase_map_edge (repo_fp, src_id, dst_id, relation, ts) VALUES (?, ?, ?, 'referenced', ?)`).run(this.repoFp, srcId, dstId, now);
+        } catch {
+        }
+      }
+      topFiles(limit = 15) {
+        const lim = Math.max(1, Math.min(100, limit));
+        try {
+          const rows = this.db.prepare(`SELECT path, last_touched_ts, metadata FROM codebase_map_node
+             WHERE repo_fp = ? AND kind = 'file'
+             ORDER BY last_touched_ts DESC
+             LIMIT ?`).all(this.repoFp, lim);
+          const out = [];
+          for (const r2 of rows) {
+            let count = 1;
+            try {
+              const m2 = r2.metadata ? JSON.parse(r2.metadata) : null;
+              if (m2 && typeof m2.count === "number")
+                count = m2.count;
+            } catch {
+            }
+            out.push({ path: r2.path, touchCount: count, lastTs: r2.last_touched_ts });
+          }
+          return out;
+        } catch {
+          return [];
+        }
+      }
+      topTests(limit = 15) {
+        const lim = Math.max(1, Math.min(100, limit));
+        try {
+          const rows = this.db.prepare(`SELECT path AS name, last_result AS result, last_touched_ts AS ts FROM codebase_map_node
+             WHERE repo_fp = ? AND kind = 'test'
+             ORDER BY last_touched_ts DESC
+             LIMIT ?`).all(this.repoFp, lim);
+          return rows.map((r2) => ({ name: r2.name, result: r2.result || "?", ts: r2.ts }));
+        } catch {
+          return [];
+        }
+      }
+      /** Compact one-line summary used for the [CODEBASE MEMORY] inject. */
+      summarize() {
+        const files = this.topFiles(8);
+        const tests = this.topTests(5);
+        const fileLine = files.length > 0 ? files.slice(0, 5).map((f2) => f2.path.split("/").slice(-2).join("/")).join(", ") : "<none>";
+        const testLine = tests.length > 0 ? tests.map((t2) => `${t2.name.split("/").slice(-1)[0]}=${t2.result}`).join(", ") : "<none>";
+        return `repo=${this.repoFp} files-touched=${files.length} (top: ${fileLine}); tests-tracked=${tests.length} (recent: ${testLine})`;
+      }
+      /** Stable composite id: `<kind>:<sha16(path)>` so insert ON CONFLICT works. */
+      idFor(kind, path8) {
+        const h = createHash11("sha256").update(`${this.repoFp}:${kind}:${path8}`).digest("hex").slice(0, 24);
+        return `${kind}-${h}`;
+      }
+    };
+  }
+});
+
+// packages/memory/dist/embeddingDrift.js
+function ensureSchema(db) {
+  try {
+    db.exec(`CREATE TABLE IF NOT EXISTS embedding_meta (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      model_name TEXT NOT NULL,
+      dim INTEGER NOT NULL,
+      set_at_ts INTEGER NOT NULL
+    )`);
+  } catch {
+  }
+}
+function checkEmbeddingDrift(db, current) {
+  ensureSchema(db);
+  try {
+    const row = db.prepare(`SELECT model_name, dim, set_at_ts FROM embedding_meta WHERE id = 1`).get();
+    if (!row)
+      return { driftDetected: false };
+    const prev = { model: row.model_name, dim: row.dim, ts: row.set_at_ts };
+    const drift = prev.model !== current.model || prev.dim !== current.dim;
+    return { driftDetected: drift, previous: prev };
+  } catch {
+    return { driftDetected: false };
+  }
+}
+function recordEmbeddingMeta(db, sig) {
+  ensureSchema(db);
+  try {
+    db.prepare(`INSERT INTO embedding_meta (id, model_name, dim, set_at_ts)
+         VALUES (1, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           model_name = excluded.model_name,
+           dim = excluded.dim,
+           set_at_ts = excluded.set_at_ts`).run(sig.model, sig.dim, Date.now());
+  } catch {
+  }
+}
+async function reembedAll(db, embedFn, opts = {}) {
+  const batch2 = Math.max(1, Math.min(500, opts.batchSize ?? 50));
+  let total = 0;
+  try {
+    const r2 = db.prepare(`SELECT COUNT(*) AS c FROM episodes WHERE content IS NOT NULL AND length(content) > 0`).get();
+    total = r2?.c ?? 0;
+  } catch {
+    return { reembedded: 0, skipped: 0, total: 0 };
+  }
+  if (total === 0)
+    return { reembedded: 0, skipped: 0, total: 0 };
+  let done = 0;
+  let reembedded = 0;
+  let skipped = 0;
+  let offset = 0;
+  while (offset < total) {
+    let rows = [];
+    try {
+      rows = db.prepare(`SELECT id, content FROM episodes
+                  WHERE content IS NOT NULL AND length(content) > 0
+                  ORDER BY rowid ASC LIMIT ? OFFSET ?`).all(batch2, offset);
+    } catch {
+      break;
+    }
+    if (rows.length === 0)
+      break;
+    const updates = [];
+    for (const r2 of rows) {
+      try {
+        const vec = await embedFn(r2.content);
+        if (vec && vec.length > 0) {
+          updates.push({ id: r2.id, vec });
+        } else {
+          skipped++;
+        }
+      } catch {
+        skipped++;
+      }
+    }
+    if (updates.length > 0) {
+      try {
+        const stmt = db.prepare(`UPDATE episodes SET embedding = ? WHERE id = ?`);
+        const tx = db.transaction((batch3) => {
+          for (const u of batch3) {
+            stmt.run(Buffer.from(u.vec.buffer, u.vec.byteOffset, u.vec.byteLength), u.id);
+          }
+        });
+        tx(updates);
+        reembedded += updates.length;
+      } catch {
+      }
+    }
+    done += rows.length;
+    if (opts.onProgress) {
+      try {
+        opts.onProgress(done, total);
+      } catch {
+      }
+    }
+    offset += rows.length;
+  }
+  return { reembedded, skipped, total };
+}
+var init_embeddingDrift = __esm({
+  "packages/memory/dist/embeddingDrift.js"() {
     "use strict";
   }
 });
@@ -521804,12 +522547,14 @@ __export(dist_exports2, {
   CRLParser: () => CRLParser,
   CRLTemplateResolver: () => CRLTemplateResolver,
   CRL_SYMBOLS: () => CRL_SYMBOLS,
+  CodebaseMap: () => CodebaseMap,
   ConfidenceTracker: () => ConfidenceTracker,
   DECAY_TAU: () => DECAY_TAU,
   DEFAULT_CRL_CONFIG: () => DEFAULT_CRL_CONFIG,
   DEFAULT_ENCODING: () => DEFAULT_ENCODING,
   DEFAULT_RETRIEVAL: () => DEFAULT_RETRIEVAL,
   DEFAULT_TARGET: () => DEFAULT_TARGET,
+  DEFAULT_WINDOW_MS: () => DEFAULT_WINDOW_MS,
   EmbeddingAligner: () => EmbeddingAligner,
   EpisodeStore: () => EpisodeStore,
   FailureStore: () => FailureStore,
@@ -521824,6 +522569,7 @@ __export(dist_exports2, {
   SocialMemoryStore: () => SocialMemoryStore,
   TaskMemoryStore: () => TaskMemoryStore,
   TemporalGraph: () => TemporalGraph,
+  ToolOutcomeTracker: () => ToolOutcomeTracker,
   ToolPatternStore: () => ToolPatternStore,
   ValidationStore: () => ValidationStore,
   applyInfluence: () => applyInfluence,
@@ -521832,9 +522578,12 @@ __export(dist_exports2, {
   autoDecayClass: () => autoDecayClass,
   autoImportance: () => autoImportance,
   batchLink: () => batchLink,
+  buildGist: () => buildGist,
+  buildSelfTrustInfluence: () => buildSelfTrustInfluence,
   buildTrace: () => buildTrace,
   characteristicsForStage: () => characteristicsForStage,
   checkEmbeddingAvailable: () => checkEmbeddingAvailable,
+  checkEmbeddingDrift: () => checkEmbeddingDrift,
   closeDb: () => closeDb,
   compressAndStore: () => compressAndStore,
   compressToGist: () => compressToGist,
@@ -521843,6 +522592,7 @@ __export(dist_exports2, {
   cosineSimilarity: () => cosineSimilarity2,
   createCRLMemoryStore: () => createCRLMemoryStore,
   createHomeostaticState: () => createHomeostaticState,
+  crystallize: () => crystallize,
   detectStage: () => detectStage,
   developmentalReport: () => report,
   deviationFromTarget: () => deviationFromTarget,
@@ -521853,24 +522603,33 @@ __export(dist_exports2, {
   extractQueryEntities: () => extractQueryEntities,
   extractTrace: () => extractTrace,
   findNeighbors: () => findNeighbors,
+  fingerprintSignature: () => fingerprintSignature,
+  freshNodeId: () => freshNodeId,
   generateEmbedding: () => generateEmbedding,
   generateEmbeddingBatch: () => generateEmbeddingBatch,
   getCRLConfigStore: () => getCRLConfigStore,
+  goalHashOf: () => goalHashOf,
   importanceMultiplier: () => importanceMultiplier,
+  inferDomainFromEpisode: () => inferDomainFromEpisode,
   initDb: () => initDb,
+  isSessionGist: () => isSessionGist,
   lightSleep: () => lightSleep,
   linkEpisode: () => linkEpisode,
+  lookupBySignature: () => lookupBySignature,
   modulateImportance: () => modulateImportance,
   modulateRetrievalScore: () => modulateRetrievalScore,
   noveltyBias: () => noveltyBias,
   observeEmotionalState: () => observeEmotionalState,
   personalizedPageRank: () => personalizedPageRank,
   reciprocityBias: () => reciprocityBias,
+  recordEmbeddingMeta: () => recordEmbeddingMeta,
+  reembedAll: () => reembedAll,
   remDream: () => remDream,
   resetCRLConfigStore: () => resetCRLConfigStore,
   retrieveByPPR: () => retrieveByPPR,
   runConsolidationCycle: () => runConsolidationCycle,
   sanitizeEmotionalState: () => sanitizeEmotionalState,
+  selfTrustFor: () => selfTrustFor,
   slowWaveReplay: () => slowWaveReplay,
   splanifoldCosine: () => cosine,
   splanifoldDeserialize: () => deserialize,
@@ -521914,6 +522673,12 @@ var init_dist7 = __esm({
     init_developmentalStage();
     init_memoryStageContext();
     init_socialInfluence();
+    init_sessionGist();
+    init_selfTrust();
+    init_toolOutcomes();
+    init_stagnationRecipes();
+    init_codebaseMap();
+    init_embeddingDrift();
   }
 });
 
@@ -523547,7 +524312,7 @@ import { existsSync as existsSync66, readFileSync as readFileSync54, statSync as
 import { execSync as execSync45 } from "node:child_process";
 import { homedir as homedir22, platform as platform2, arch as arch2, totalmem as totalmem2, freemem as freemem2, hostname as hostname3 } from "node:os";
 import { join as join82 } from "node:path";
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
   const warnings = [];
   const configFingerprints = {};
@@ -523714,7 +524479,7 @@ function expandPath(p2) {
   return p2;
 }
 function sha2563(s2) {
-  return createHash9("sha256").update(s2).digest("hex").slice(0, 16);
+  return createHash12("sha256").update(s2).digest("hex").slice(0, 16);
 }
 function freeDiskBytes(path8 = "/tmp") {
   try {
@@ -524987,6 +525752,37 @@ var init_agenticRunner = __esm({
       _patchHistoryStore = null;
       _toolSequence = [];
       // Track tool calls for pattern detection
+      // MEM_PATH item #1: per-run signals consumed by sessionGist at task_complete.
+      _runStartTime = 0;
+      _runErrorCount = 0;
+      _runErrorPatterns = [];
+      // top-N short error keys collected this run
+      _runWhatWorked = [];
+      // strings extracted from StuckMetaAnalyzer / lessons
+      // MEM_PATH item #2: retrieved-episode IDs surfaced last turn. The next
+      // assistant turn scans its output for content fingerprints from these
+      // episodes; matches bump reuse_count via episodeStore.bumpReuseCount.
+      _lastRetrievedEpisodes = [];
+      // MEM_PATH item #4: per-(tool, domain) success-rate tracker. Populated
+      // post-tool-result; consulted pre-tool-call to inject [FORECAST]
+      // warnings when historical success rate is low.
+      _toolOutcomeTracker = null;
+      // lazy-init: ToolOutcomeTracker
+      // Track turns where a forecast was emitted so we don't pile on.
+      _lastForecastTurn = -10;
+      // MEM_PATH item #5: most-recent stagnation entry fingerprint. When the
+      // cooldown expires and the next 3 turns succeed, this is consumed by
+      // the crystallization block to persist a recipe. Reset after consumption
+      // (to prevent double-write) or when stagnation re-enters.
+      _pendingStagnationEntry = null;
+      // MEM_PATH item #8: persistent codebase map (lazy-init at session start).
+      _codebaseMap = null;
+      // MEM_PATH item #9: adaptive retrieval cache. When the (goalHash, recent-tool-sig)
+      // hasn't changed since last retrieval, skip the PPR call entirely and reuse
+      // the previous memoryLines.
+      _lastPprSig = null;
+      _lastPprMemoryLines = [];
+      _pprSkipCount = 0;
       // Phase 2 — tool subset expansion and usage tracking.
       // Tools promoted from deferred → inline by tool_search (or by subset
       // expansion). They stay inline for the rest of the run unless idle past
@@ -527116,6 +527912,10 @@ Respond with your assessment, then take action.`;
           modifiedFiles: /* @__PURE__ */ new Map(),
           toolCallCount: 0
         };
+        this._runStartTime = Date.now();
+        this._runErrorCount = 0;
+        this._runErrorPatterns = [];
+        this._runWhatWorked = [];
         this._fileRegistry.clear();
         this._memexArchive.clear();
         this._sessionId = process.env["OA_SESSION_ID"] && String(process.env["OA_SESSION_ID"]) || `session-${Date.now()}`;
@@ -527169,6 +527969,13 @@ Respond with your assessment, then take action.`;
               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})`,
@@ -527177,6 +527984,46 @@ Respond with your assessment, then take action.`;
           } catch {
           }
         }
+        if (process.env["OA_DISABLE_EMBEDDING_DRIFT_CHECK"] !== "1" && this._episodeStore) {
+          try {
+            const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+            const currentModel = process.env["OA_EMBEDDING_MODEL"] || "default";
+            const currentDim = parseInt(process.env["OA_EMBEDDING_DIM"] || "0", 10) || 768;
+            const drift = memMod.checkEmbeddingDrift(this._episodeStore.getDb(), { model: currentModel, dim: currentDim });
+            if (drift.driftDetected && drift.previous) {
+              this.emit({
+                type: "status",
+                content: `[EMBEDDING DRIFT] previous=${drift.previous.model}/${drift.previous.dim}d, current=${currentModel}/${currentDim}d — REM cosine similarity will be unreliable until reembedAll runs`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            } else if (!drift.previous) {
+              memMod.recordEmbeddingMeta(this._episodeStore.getDb(), { model: currentModel, dim: currentDim });
+            }
+          } catch {
+          }
+        }
+        if (process.env["OA_DISABLE_CODEBASE_MAP"] !== "1" && this._episodeStore && this._workingDirectory) {
+          try {
+            const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+            let commitSha = "no-commit";
+            try {
+              const { execSync: execSync59 } = await import("node:child_process");
+              commitSha = execSync59("git rev-parse HEAD", { cwd: this._workingDirectory, stdio: ["ignore", "pipe", "ignore"] }).toString().trim().slice(0, 12) || "no-commit";
+            } catch {
+            }
+            const cm = new memMod.CodebaseMap(this._episodeStore.getDb(), this._workingDirectory, commitSha);
+            const restored = cm.restore();
+            this._codebaseMap = cm;
+            if (restored.nodes > 0) {
+              this.emit({
+                type: "status",
+                content: `[CODEBASE MEMORY] restored ${restored.nodes} files / ${restored.edges} edges from prior sessions: ${cm.summarize().slice(0, 220)}`,
+                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));
@@ -527513,6 +528360,9 @@ TASK: ${task}` : task;
                 minSamples: STAG_MIN_SAMPLES
               })) {
                 let _stagBody = buildStagnationDiagnostic(signals);
+                if (process.env["OA_DISABLE_STAGNATION_REPLAN"] !== "1") {
+                  _stagBody += "\n\n[STAGNATION REPLAN — required structure]\nYou have made repeated unsuccessful attempts. STOP retrying.\nRespond with EXACTLY this structure before your next tool call:\n\n  HYPOTHESES (3 distinct theories why progress stalled):\n  1. ...\n  2. ...\n  3. ...\n  PICK: <number 1-3>\n  WHY: <one sentence>\n  FALSIFICATION: <observable signal that would refute the pick>\n  NEXT ACTION: <single tool call to test the picked hypothesis>\n\nIf you cannot list 3 distinct hypotheses, ask the human via task_complete with a 'blocked' summary.";
+                }
                 if (this._runLessons.length > 0) {
                   const _query = `${this._taskState.goal || ""} ${signals.variantList.join(" ")}`;
                   const _topLessons = select2({
@@ -527534,11 +528384,89 @@ TASK: ${task}` : task;
                 }
                 messages2.push({ role: "system", content: _stagBody });
                 stagnationCooldownUntilTurn = turn + 5;
+                try {
+                  const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                  const errClusters = [];
+                  try {
+                    const ec = this._errorClusterTracker;
+                    if (ec && typeof ec.topClusters === "function") {
+                      const top = ec.topClusters(3);
+                      for (const c9 of top)
+                        errClusters.push(c9.pattern);
+                    }
+                  } catch {
+                  }
+                  if (errClusters.length === 0 && this._runErrorPatterns.length > 0) {
+                    errClusters.push(...this._runErrorPatterns.slice(0, 3));
+                  }
+                  const stuckTool = this._toolSequence.length > 0 ? this._toolSequence[this._toolSequence.length - 1] : null;
+                  const fingerprint = { errorClusters: errClusters.slice(0, 3), stuckTool };
+                  this._pendingStagnationEntry = {
+                    fingerprint,
+                    cooldownExpiresAtTurn: turn + 5,
+                    successesSinceExpiry: 0,
+                    stuckTool
+                  };
+                  const sig = memMod.fingerprintSignature(fingerprint);
+                  const recipes = this._episodeStore ? memMod.lookupBySignature(this._episodeStore, sig, 1) : [];
+                  if (recipes.length > 0) {
+                    const r2 = recipes[0];
+                    messages2.push({
+                      role: "system",
+                      content: `[STAGNATION RECIPE — found from prior run with same failure shape]
+${r2.content}
+If this matches your current shape, try it before continuing.`
+                    });
+                    this.emit({
+                      type: "status",
+                      content: `[STAGNATION RECIPE] surfaced prior recipe (sig=${sig}) for current failure shape`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                } catch {
+                }
                 this.emit({
                   type: "status",
                   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 {
+                }
               }
             }
           }
@@ -528390,19 +529318,96 @@ If you're stuck, try a completely different approach. Do NOT repeat what failed
             }
           }
           if (turn > 0 && turn % 3 === 0 && this._temporalGraph && this._episodeStore) {
+            let shouldRetrieve = true;
             try {
-              const taskGoal = this._taskState.goal || cleanedTask.slice(0, 200);
-              const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, { topK: 3 });
-              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({
-                  role: "system",
-                  content: `[Associative Memory — related prior experience]
-${memoryLines.join("\n")}`
-                });
+              if (process.env["OA_DISABLE_ADAPTIVE_RETRIEVAL"] !== "1") {
+                const goalForSig = (this._taskState.goal || "").slice(0, 200);
+                const recentTools = this._toolSequence.slice(-5).join("|");
+                const { createHash: createHash20 } = await import("node:crypto");
+                const sig = createHash20("sha256").update(`${goalForSig}::${recentTools}`).digest("hex").slice(0, 16);
+                if (this._lastPprSig === sig && this._lastPprMemoryLines.length > 0) {
+                  compacted.push({
+                    role: "system",
+                    content: `[Associative Memory — related prior experience]
+${this._lastPprMemoryLines.join("\n")}`
+                  });
+                  this._pprSkipCount++;
+                  this.emit({
+                    type: "status",
+                    content: `[ppr-skip] reused previous retrieval (skipCount=${this._pprSkipCount}) — goal+tools unchanged`,
+                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                  });
+                  shouldRetrieve = false;
+                } else {
+                  this._lastPprSig = sig;
+                  this._pprSkipCount = 0;
+                }
               }
             } catch {
             }
+            if (!shouldRetrieve) {
+            } else {
+              try {
+                if (this._lastRetrievedEpisodes.length > 0) {
+                  const recentAsst = messages2.slice(-10).filter((m2) => m2.role === "assistant" && typeof m2.content === "string").map((m2) => m2.content.toLowerCase()).join(" ");
+                  let bumped = 0;
+                  for (const { id, fingerprint } of this._lastRetrievedEpisodes) {
+                    if (fingerprint && fingerprint.length >= 10 && recentAsst.includes(fingerprint)) {
+                      this._episodeStore.bumpReuseCount(id, 1);
+                      bumped++;
+                    }
+                  }
+                  if (bumped > 0) {
+                    this.emit({
+                      type: "status",
+                      content: `[reuse] ${bumped} retrieved episode(s) referenced — bumping reuse_count`,
+                      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                  }
+                  this._lastRetrievedEpisodes = [];
+                }
+              } catch {
+              }
+              try {
+                const taskGoal = this._taskState.goal || cleanedTask.slice(0, 200);
+                const _hs = this._homeostat;
+                let _influenceFor = void 0;
+                try {
+                  const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                  const sm = this._selfModel;
+                  if (sm) {
+                    const cal = sm.snapshot()?.calibration;
+                    const closure = memMod.buildSelfTrustInfluence(cal);
+                    if (closure)
+                      _influenceFor = closure;
+                  }
+                } catch {
+                }
+                const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, {
+                  topK: 3,
+                  currentEmotionalState: _hs?.current,
+                  engagementWeight: 0.2,
+                  influenceFor: _influenceFor
+                });
+                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({
+                    role: "system",
+                    content: `[Associative Memory — related prior experience]
+${memoryLines.join("\n")}`
+                  });
+                  this._lastRetrievedEpisodes = pprResult.episodes.map(({ episode }) => ({
+                    id: episode.id,
+                    fingerprint: (episode.content || "").trim().slice(0, 50).toLowerCase()
+                  }));
+                  this._lastPprMemoryLines = memoryLines;
+                } else {
+                  this._lastRetrievedEpisodes = [];
+                  this._lastPprMemoryLines = [];
+                }
+              } catch {
+              }
+            }
           }
           if (this.options.environmentProvider) {
             try {
@@ -529160,6 +530165,22 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                       }
                     } else {
                       const finalArgs = hookCheck.modifiedArgs ?? tc.arguments;
+                      if (this._toolOutcomeTracker && process.env["OA_DISABLE_TOOL_FORECAST"] !== "1") {
+                        try {
+                          const argBlob = JSON.stringify(finalArgs || {}).toLowerCase();
+                          const fdomain = /\.tsx?\b|tsc|typescript|vitest|jest/.test(argBlob) ? "typescript" : /\.py\b|pytest|python/.test(argBlob) ? "python" : /\.rs\b|cargo/.test(argBlob) ? "rust" : /\bgo\.mod\b|\.go\b|go test|go build/.test(argBlob) ? "golang" : /node_modules|package\.json|npm |pnpm |yarn /.test(argBlob) ? "node" : "general";
+                          const recent = this._toolOutcomeTracker.recentRate(tc.name, fdomain);
+                          const inStagnation = stagnationCooldownUntilTurn > turn;
+                          const cooldownExpired = turn - this._lastForecastTurn >= 3;
+                          if (recent && recent.rate < 0.3 && !inStagnation && cooldownExpired) {
+                            this._lastForecastTurn = turn;
+                            const fc = `[FORECAST] historical success rate for tool "${tc.name}" in domain "${fdomain}" is ${Math.round(recent.rate * 100)}% over ${recent.n} recent calls. Consider an alternative approach or break the task down before retrying.`;
+                            messages2.push({ role: "system", content: fc });
+                            this.emit({ type: "status", content: fc, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+                          }
+                        } catch {
+                        }
+                      }
                       try {
                         if (typeof tool.executeStream === "function") {
                           const gen = tool.executeStream(finalArgs);
@@ -529923,6 +530944,103 @@ ${criticDecision.cachedResult.slice(0, 500)}` : `[BLOCKED — the observer confi
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
               this._taskState.toolCallCount++;
+              if (result && result.success === false) {
+                this._runErrorCount++;
+                const errMsg = result.error || "";
+                if (typeof errMsg === "string" && errMsg.length > 0) {
+                  const sig = errMsg.replace(/[0-9]+/g, "N").slice(0, 60);
+                  if (!this._runErrorPatterns.includes(sig)) {
+                    this._runErrorPatterns.push(sig);
+                    if (this._runErrorPatterns.length > 5)
+                      this._runErrorPatterns.length = 5;
+                  }
+                }
+                try {
+                  if (process.env["OA_DISABLE_MIDTURN_RETRIEVAL"] !== "1" && this._episodeStore && stagnationCooldownUntilTurn <= turn && typeof errMsg === "string" && errMsg.length >= 8) {
+                    const query = `${tc.name} ${errMsg}`.slice(0, 240);
+                    const past = this._episodeStore.search({ query, limit: 2 });
+                    const useful = past.filter((p2) => p2.content && p2.content.length > 10).slice(0, 1);
+                    if (useful.length > 0) {
+                      const u = useful[0];
+                      messages2.push({
+                        role: "system",
+                        content: `[Past-error memory] when "${tc.name}" failed before with similar error, episode said: ${u.content.slice(0, 200)}`
+                      });
+                      this.emit({
+                        type: "status",
+                        content: `[midturn] surfaced past-error memory for tool=${tc.name}`,
+                        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    }
+                  }
+                } catch {
+                }
+              }
+              try {
+                if (this._pendingStagnationEntry && process.env["OA_DISABLE_STAGNATION_RECIPES"] !== "1") {
+                  if (turn > this._pendingStagnationEntry.cooldownExpiresAtTurn) {
+                    if (result && result.success !== false) {
+                      this._pendingStagnationEntry.successesSinceExpiry++;
+                      if (this._pendingStagnationEntry.successesSinceExpiry >= 3 && this._episodeStore) {
+                        const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                        const recoveryTool = tc.name;
+                        const stuck = this._pendingStagnationEntry.stuckTool || null;
+                        const toolShift = stuck && stuck !== recoveryTool ? { from: stuck, to: recoveryTool } : null;
+                        const recId = memMod.crystallize(this._episodeStore, {
+                          fingerprint: this._pendingStagnationEntry.fingerprint,
+                          toolShift,
+                          whatWorked: this._runLessons.slice(-1).map((l2) => l2?.whatWorked).join(" ").slice(0, 120) || `recovered after switching to ${recoveryTool}`
+                        });
+                        this.emit({
+                          type: "status",
+                          content: `[STAGNATION CRYSTALLIZED] recipe id=${recId.slice(0, 8)} for failure shape (sig=${memMod.fingerprintSignature(this._pendingStagnationEntry.fingerprint)})`,
+                          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                        });
+                        this._pendingStagnationEntry = null;
+                      }
+                    } else {
+                      this._pendingStagnationEntry.successesSinceExpiry = 0;
+                    }
+                  }
+                }
+              } catch {
+              }
+              try {
+                if (this._codebaseMap) {
+                  const args = tc.arguments || {};
+                  const path8 = typeof args.path === "string" ? args.path : "";
+                  const command = typeof args.command === "string" ? args.command : "";
+                  const isWrite = /^(file_(write|edit|patch)|batch_edit|edit)$/i.test(tc.name);
+                  const isRead = /^(file_read|read)$/i.test(tc.name);
+                  if (path8)
+                    this._codebaseMap.noteFile(path8, isWrite ? "write" : "read");
+                  if (command && /\b(vitest|jest|pytest|go test|cargo test)\b/.test(command)) {
+                    const ok2 = result && result.success !== false;
+                    this._codebaseMap.noteTest(command.slice(0, 80), ok2 ? "pass" : "fail");
+                  }
+                  if (typeof args.from === "string" && typeof args.to === "string") {
+                    this._codebaseMap.noteReference(args.from, args.to);
+                  }
+                }
+              } catch {
+              }
+              try {
+                if (process.env["OA_DISABLE_TOOL_FORECAST"] !== "1") {
+                  if (!this._toolOutcomeTracker) {
+                    const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                    this._toolOutcomeTracker = new memMod.ToolOutcomeTracker();
+                  }
+                  const argBlob = JSON.stringify(tc.arguments || {}).toLowerCase();
+                  const domain = /\.tsx?\b|tsc|typescript|vitest|jest/.test(argBlob) ? "typescript" : /\.py\b|pytest|python/.test(argBlob) ? "python" : /\.rs\b|cargo/.test(argBlob) ? "rust" : /\bgo\.mod\b|\.go\b|go test|go build/.test(argBlob) ? "golang" : /node_modules|package\.json|npm |pnpm |yarn /.test(argBlob) ? "node" : "general";
+                  this._toolOutcomeTracker.record({
+                    tool: tc.name,
+                    domain,
+                    success: result && result.success !== false,
+                    ts: Date.now()
+                  });
+                }
+              } catch {
+              }
               const filePath = typeof tc.arguments?.path === "string" ? tc.arguments.path : "";
               recordToolExecution(this._appState, tc.name, performance.now() - toolStart, result.success, filePath || void 0);
               if (tc.name === "todo_write") {
@@ -531165,6 +532283,45 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
               } catch {
               }
             }
+            if (process.env["OA_DISABLE_SESSION_GIST"] !== "1") {
+              try {
+                const memMod = await Promise.resolve().then(() => (init_dist7(), dist_exports2));
+                const goal = this._taskState.originalGoal || this._taskState.goal || "";
+                const durationMs2 = this._runStartTime > 0 ? Math.max(0, Date.now() - this._runStartTime) : 0;
+                const toolCounts = /* @__PURE__ */ new Map();
+                for (const t2 of this._toolSequence)
+                  toolCounts.set(t2, (toolCounts.get(t2) ?? 0) + 1);
+                const topToolNames = [...toolCounts.entries()].sort((a2, b) => b[1] - a2[1]).slice(0, 3).map(([n2]) => n2);
+                const whatWorked = this._runLessons.slice(-3).map((l2) => l2.whatWorked).filter(Boolean);
+                const finalStatus = completed ? "complete" : this._runErrorCount > this._taskState.toolCallCount * 0.5 ? "abandoned" : "abandoned";
+                const gist2 = memMod.buildGist({
+                  goal,
+                  durationMs: durationMs2,
+                  toolCallCount: this._taskState.toolCallCount,
+                  errorCount: this._runErrorCount,
+                  finalStatus,
+                  topToolNames,
+                  topErrorPatterns: this._runErrorPatterns.slice(0, 3),
+                  whatWorked,
+                  workingDirectory: this._workingDirectory || void 0
+                });
+                this._episodeStore.insert({
+                  sessionId: this._sessionId,
+                  modality: "gist",
+                  toolName: "session_gist",
+                  content: gist2.content,
+                  importance: 8,
+                  decayClass: "procedural",
+                  metadata: gist2.metadata
+                });
+                this.emit({
+                  type: "status",
+                  content: `[SESSION GIST] domain=${gist2.metadata.domain} status=${gist2.metadata.finalStatus} tools=${gist2.metadata.toolCount} errs=${gist2.metadata.errorCount} goalHash=${gist2.goalHash}`,
+                  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));
@@ -540355,7 +541512,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes25, createHash: createHash17 } = __require("crypto");
+    var { randomBytes: randomBytes25, createHash: createHash20 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate3();
@@ -541015,7 +542172,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash20("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -541382,7 +542539,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter13 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash17 } = __require("crypto");
+    var { createHash: createHash20 } = __require("crypto");
     var extension2 = require_extension3();
     var PerMessageDeflate2 = require_permessage_deflate3();
     var subprotocol2 = require_subprotocol2();
@@ -541683,7 +542840,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash20("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -542743,7 +543900,7 @@ __export(oa_directory_exports, {
 import { existsSync as existsSync73, mkdirSync as mkdirSync39, readFileSync as readFileSync58, writeFileSync as writeFileSync35, readdirSync as readdirSync21, statSync as statSync25, unlinkSync as unlinkSync14, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync3 } from "node:fs";
 import { join as join90, relative as relative8, basename as basename14, dirname as dirname27 } from "node:path";
 import { homedir as homedir26 } from "node:os";
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function findGitRoot(startDir) {
   let dir = startDir;
   const visited = /* @__PURE__ */ new Set();
@@ -543108,7 +544265,7 @@ function buildHandoffPrompt(repoRoot) {
   return lines.join("\n");
 }
 function computeDedupeHash(task, savedAt) {
-  return createHash10("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+  return createHash13("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
 }
 function generateSessionId() {
   const timestamp = Date.now().toString(36);
@@ -571639,7 +572796,7 @@ var init_types = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes19, scryptSync as scryptSync2, createHash as createHash11 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes19, scryptSync as scryptSync2, createHash as createHash14 } from "node:crypto";
 import { readFileSync as readFileSync68, writeFileSync as writeFileSync43, existsSync as existsSync85, mkdirSync as mkdirSync47 } from "node:fs";
 import { dirname as dirname31 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -571884,7 +573041,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash11("sha256");
+        const hash = createHash14("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -571899,7 +573056,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter7 } from "node:events";
 import { createServer as createServer5 } from "node:http";
-import { randomBytes as randomBytes20, createHash as createHash12, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes20, createHash as createHash15, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -571916,7 +573073,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash12("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash15("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes20(24).toString("base64url");
@@ -579796,7 +580953,7 @@ __export(chat_session_exports, {
   startInFlightChat: () => startInFlightChat,
   trackSessionTokens: () => trackSessionTokens
 });
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 import {
   existsSync as existsSync94,
   readFileSync as readFileSync76,
@@ -579953,7 +581110,7 @@ function getSession(sessionId, model, cwd4) {
     } catch {
     }
   }
-  const id = sessionId || randomUUID12();
+  const id = sessionId || randomUUID13();
   const systemPrompt = buildSystemPrompt(cwd4);
   const session = {
     id,
@@ -580220,7 +581377,7 @@ __export(projects_exports, {
 import { readFileSync as readFileSync77, writeFileSync as writeFileSync49, mkdirSync as mkdirSync55, existsSync as existsSync95, statSync as statSync31, renameSync as renameSync6 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
 import { basename as basename20, join as join112, resolve as resolve35 } from "node:path";
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 function readAll2() {
   try {
     if (!existsSync95(PROJECTS_FILE)) return { projects: [], schemaVersion: 1 };
@@ -580234,7 +581391,7 @@ function readAll2() {
 }
 function writeAll(file) {
   mkdirSync55(OA_DIR3, { recursive: true });
-  const tmp = `${PROJECTS_FILE}.${randomUUID13().slice(0, 8)}.tmp`;
+  const tmp = `${PROJECTS_FILE}.${randomUUID14().slice(0, 8)}.tmp`;
   writeFileSync49(tmp, JSON.stringify(file, null, 2), "utf8");
   renameSync6(tmp, PROJECTS_FILE);
 }
@@ -581023,14 +582180,14 @@ var init_access_policy = __esm({
 });
 
 // packages/cli/src/api/project-preferences.ts
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync96, mkdirSync as mkdirSync56, readFileSync as readFileSync78, renameSync as renameSync7, writeFileSync as writeFileSync50, unlinkSync as unlinkSync22 } from "node:fs";
 import { homedir as homedir36 } from "node:os";
 import { join as join113, resolve as resolve36 } from "node:path";
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve36(root);
-  return createHash13("sha256").update(canonical).digest("hex").slice(0, 16);
+  return createHash16("sha256").update(canonical).digest("hex").slice(0, 16);
 }
 function projectDir(root) {
   return join113(PROJECTS_DIR, projectKey(root));
@@ -581075,7 +582232,7 @@ function writeProjectPreferences(root, partial) {
     updatedAt: Date.now()
   };
   const file = prefsPath(root);
-  const tmp = `${file}.${randomUUID14().slice(0, 8)}.tmp`;
+  const tmp = `${file}.${randomUUID15().slice(0, 8)}.tmp`;
   writeFileSync50(tmp, JSON.stringify(merged, null, 2), "utf8");
   try {
     renameSync7(tmp, file);
@@ -582208,7 +583365,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -582271,7 +583428,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash14("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash17("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req2, res, etag) {
@@ -593886,8 +595043,8 @@ import { dirname as dirname36, join as join121, resolve as resolve38 } from "nod
 import { homedir as homedir42 } from "node:os";
 import { spawn as spawn25, execSync as execSync57 } from "node:child_process";
 import { mkdirSync as mkdirSync63, writeFileSync as writeFileSync55, readFileSync as readFileSync85, readdirSync as readdirSync36, existsSync as existsSync105, watch as fsWatch3, renameSync as renameSync8, unlinkSync as unlinkSync24 } from "node:fs";
-import { randomBytes as randomBytes23, randomUUID as randomUUID15 } from "node:crypto";
-import { createHash as createHash16 } from "node:crypto";
+import { randomBytes as randomBytes23, randomUUID as randomUUID16 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function getVersion3() {
   try {
     const thisDir = dirname36(fileURLToPath17(import.meta.url));
@@ -596971,7 +598128,7 @@ async function handleRequest(req2, res, ollamaUrl, verbose) {
   const urlObj = new URL(req2.url ?? "/", `http://${req2.headers.host ?? "localhost"}`);
   const pathname = urlObj.pathname;
   const startMs = performance.now();
-  const requestId = req2.headers["x-request-id"] || randomUUID15();
+  const requestId = req2.headers["x-request-id"] || randomUUID16();
   res.setHeader("X-Request-ID", requestId);
   res.setHeader("X-API-Version", API_VERSION);
   if (method === "OPTIONS") {
@@ -599085,7 +600242,7 @@ function listScheduledTasks() {
               const schedule = String(t2?.schedule || t2?.cron || t2?.when || "");
               const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
               const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-              const fallbackId = createHash16("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+              const fallbackId = createHash19("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
               const uid = realId || fallbackId;
               const key = `${uid}`;
               if (seen.has(key)) return;
@@ -599202,8 +600359,8 @@ function deleteScheduledById(id) {
     if (id) candidates.push(id);
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id)) candidates.push(entry.id);
     try {
-      const { createHash: createHash17 } = require3("node:crypto");
-      const fallback = createHash17("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash20 } = require3("node:crypto");
+      const fallback = createHash20("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -606610,13 +607767,13 @@ NEW TASK: ${fullInput}`;
       writeContent(() => renderError2(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash17 } = await import("node:crypto");
+          const { createHash: createHash20 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash17("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash20("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,