open-agents-ai 0.187.511 → 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 {
@@ -517338,6 +517338,22 @@ var init_episodeStore = __esm({
       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))
@@ -517377,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");
       }
@@ -517642,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
         };
       }
     };
@@ -521355,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;
@@ -521437,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
     }
   };
 }
@@ -521928,6 +521972,568 @@ var init_memoryStageContext = __esm({
   }
 });
 
+// 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 computeGoalHash(goal) {
+  return createHash9("sha256").update(goal.trim().toLowerCase()).digest("hex").slice(0, 16);
+}
+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 goalHashOf(goal) {
+  return computeGoalHash(goal);
+}
+function isSessionGist(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return false;
+  const m2 = metadata;
+  return m2["kind"] === "session_gist" && typeof m2["goalHash"] === "string";
+}
+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 };
+  };
+}
+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"]
+    };
+  }
+});
+
+// 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();
+      }
+    };
+  }
+});
+
+// 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 [];
+  }
+}
+var init_stagnationRecipes = __esm({
+  "packages/memory/dist/stagnationRecipes.js"() {
+    "use strict";
+  }
+});
+
+// packages/memory/dist/codebaseMap.js
+import { createHash as createHash11, randomUUID as randomUUID12 } from "node:crypto";
+function freshNodeId() {
+  return randomUUID12();
+}
+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";
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
@@ -521941,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,
@@ -521961,6 +522569,7 @@ __export(dist_exports2, {
   SocialMemoryStore: () => SocialMemoryStore,
   TaskMemoryStore: () => TaskMemoryStore,
   TemporalGraph: () => TemporalGraph,
+  ToolOutcomeTracker: () => ToolOutcomeTracker,
   ToolPatternStore: () => ToolPatternStore,
   ValidationStore: () => ValidationStore,
   applyInfluence: () => applyInfluence,
@@ -521969,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,
@@ -521980,6 +522592,7 @@ __export(dist_exports2, {
   cosineSimilarity: () => cosineSimilarity2,
   createCRLMemoryStore: () => createCRLMemoryStore,
   createHomeostaticState: () => createHomeostaticState,
+  crystallize: () => crystallize,
   detectStage: () => detectStage,
   developmentalReport: () => report,
   deviationFromTarget: () => deviationFromTarget,
@@ -521990,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,
@@ -522051,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();
   }
 });
 
@@ -523684,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 = {};
@@ -523851,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 {
@@ -525124,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
@@ -527253,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()}`;
@@ -527321,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));
@@ -527657,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({
@@ -527678,6 +528384,47 @@ 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)`,
@@ -528571,24 +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 _hs = this._homeostat;
-              const pprResult = retrieveByPPR(taskGoal, this._temporalGraph, this._episodeStore, {
-                topK: 3,
-                currentEmotionalState: _hs?.current,
-                engagementWeight: 0.2
-              });
-              if (pprResult.episodes.length > 0) {
-                const memoryLines = pprResult.episodes.map(({ episode, pprScore, matchedNodes }) => `- [${episode.toolName ?? episode.modality}] ${episode.content.slice(0, 120)} (via: ${matchedNodes.slice(0, 2).join(", ")})`);
-                compacted.push({
-                  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 {
@@ -529346,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);
@@ -530109,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") {
@@ -531351,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));
@@ -540541,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();
@@ -541201,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;
@@ -541568,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();
@@ -541869,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",
@@ -542929,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();
@@ -543294,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);
@@ -571825,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;
@@ -572070,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);
@@ -572085,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"() {
@@ -572102,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");
@@ -579982,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,
@@ -580139,7 +581110,7 @@ function getSession(sessionId, model, cwd4) {
     } catch {
     }
   }
-  const id = sessionId || randomUUID12();
+  const id = sessionId || randomUUID13();
   const systemPrompt = buildSystemPrompt(cwd4);
   const session = {
     id,
@@ -580406,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 };
@@ -580420,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);
 }
@@ -581209,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));
@@ -581261,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);
@@ -582394,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",
@@ -582457,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) {
@@ -594072,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));
@@ -597157,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") {
@@ -599271,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;
@@ -599388,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 {
     }
@@ -606796,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,