open-agents-ai 0.187.503 → 0.187.506

package/dist/index.js

@@ -4609,17 +4609,17 @@ var init_memory_search = __esm({
           try {
             const { join: pathJoin } = await import("node:path");
             const { existsSync: pathExists } = await import("node:fs");
-            const { createRequire: createRequire7 } = await import("node:module");
+            const { createRequire: createRequire8 } = await import("node:module");
             const oaDir = pathJoin(this.workingDir, ".oa");
             const epDbPath = pathJoin(oaDir, "episodes.db");
             const kgDbPath = pathJoin(oaDir, "knowledge.db");
             if (!pathExists(epDbPath)) {
               return { success: true, output: `No episode store found. Run tasks to build the knowledge graph.`, durationMs: performance.now() - start2 };
             }
-            const req2 = createRequire7(import.meta.url);
-            const Database2 = req2("better-sqlite3");
+            const req2 = createRequire8(import.meta.url);
+            const Database = req2("better-sqlite3");
             if (mode === "episodes") {
-              const db = new Database2(epDbPath, { readonly: true });
+              const db = new Database(epDbPath, { readonly: true });
               const queryLower = query.toLowerCase();
               const rows = db.prepare(`
             SELECT * FROM episodes
@@ -4642,7 +4642,7 @@ ${lines.join("\n\n")}`,
               };
             }
             if (mode === "graph" && pathExists(kgDbPath)) {
-              const db = new Database2(kgDbPath, { readonly: true });
+              const db = new Database(kgDbPath, { readonly: true });
               const queryLower = query.toLowerCase();
               const nodes = db.prepare(`
             SELECT * FROM kg_nodes WHERE text LIKE ? ORDER BY mention_count DESC LIMIT 20
@@ -4662,7 +4662,7 @@ ${lines.join("\n\n")}`,
               db.close();
               const epLines = [];
               if (episodeIds.size > 0 && pathExists(epDbPath)) {
-                const epDb = new Database2(epDbPath, { readonly: true });
+                const epDb = new Database(epDbPath, { readonly: true });
                 for (const epId of [...episodeIds].slice(0, maxResults)) {
                   const ep = epDb.prepare("SELECT * FROM episodes WHERE id = ?").get(epId);
                   if (ep)
@@ -5446,51 +5446,51 @@ var init_aiwg_health = __esm({
         const start2 = performance.now();
         const projectDir2 = args["project_dir"] || this.workingDir;
         const detailed = args["detailed"] ?? false;
-        const report = [];
-        report.push("# SDLC Health Report\n");
+        const report2 = [];
+        report2.push("# SDLC Health Report\n");
         const aiwgDir = join14(projectDir2, ".aiwg");
         const hasAiwg = existsSync10(aiwgDir);
-        report.push(`## AIWG Framework: ${hasAiwg ? "DEPLOYED" : "NOT DEPLOYED"}`);
+        report2.push(`## AIWG Framework: ${hasAiwg ? "DEPLOYED" : "NOT DEPLOYED"}`);
         if (hasAiwg) {
           const aiwgArtifacts = this.scanAiwgArtifacts(aiwgDir);
-          report.push(`  Artifacts found: ${aiwgArtifacts.total}`);
+          report2.push(`  Artifacts found: ${aiwgArtifacts.total}`);
           for (const [category, count] of Object.entries(aiwgArtifacts.categories)) {
-            report.push(`    ${category}: ${count} file(s)`);
+            report2.push(`    ${category}: ${count} file(s)`);
           }
         } else {
-          report.push("  Tip: Run aiwg_setup to deploy SDLC framework");
+          report2.push("  Tip: Run aiwg_setup to deploy SDLC framework");
         }
-        report.push("");
-        report.push("## Project Structure");
+        report2.push("");
+        report2.push("## Project Structure");
         const structure = this.analyzeStructure(projectDir2);
-        report.push(`  Package manager: ${structure.packageManager}`);
-        report.push(`  Language: ${structure.language}`);
-        report.push(`  Has tests: ${structure.hasTests ? "YES" : "NO"}`);
-        report.push(`  Has CI/CD: ${structure.hasCiCd ? "YES" : "NO"}`);
-        report.push(`  Has README: ${structure.hasReadme ? "YES" : "NO"}`);
-        report.push(`  Has LICENSE: ${structure.hasLicense ? "YES" : "NO"}`);
-        report.push(`  Has .gitignore: ${structure.hasGitignore ? "YES" : "NO"}`);
-        report.push("");
-        report.push("## Documentation");
+        report2.push(`  Package manager: ${structure.packageManager}`);
+        report2.push(`  Language: ${structure.language}`);
+        report2.push(`  Has tests: ${structure.hasTests ? "YES" : "NO"}`);
+        report2.push(`  Has CI/CD: ${structure.hasCiCd ? "YES" : "NO"}`);
+        report2.push(`  Has README: ${structure.hasReadme ? "YES" : "NO"}`);
+        report2.push(`  Has LICENSE: ${structure.hasLicense ? "YES" : "NO"}`);
+        report2.push(`  Has .gitignore: ${structure.hasGitignore ? "YES" : "NO"}`);
+        report2.push("");
+        report2.push("## Documentation");
         const docs = this.analyzeDocumentation(projectDir2);
-        report.push(`  README quality: ${docs.readmeQuality}`);
-        report.push(`  API docs: ${docs.hasApiDocs ? "YES" : "NO"}`);
-        report.push(`  Architecture docs: ${docs.hasArchDocs ? "YES" : "NO"}`);
-        report.push(`  Doc files found: ${docs.docFileCount}`);
-        report.push("");
+        report2.push(`  README quality: ${docs.readmeQuality}`);
+        report2.push(`  API docs: ${docs.hasApiDocs ? "YES" : "NO"}`);
+        report2.push(`  Architecture docs: ${docs.hasArchDocs ? "YES" : "NO"}`);
+        report2.push(`  Doc files found: ${docs.docFileCount}`);
+        report2.push("");
         const score = this.calculateMaturityScore(hasAiwg, structure, docs);
-        report.push("## SDLC Maturity Score");
-        report.push(`  Score: ${score.total}/100`);
-        report.push(`  Level: ${score.level}`);
-        report.push("");
-        report.push("  Breakdown:");
+        report2.push("## SDLC Maturity Score");
+        report2.push(`  Score: ${score.total}/100`);
+        report2.push(`  Level: ${score.level}`);
+        report2.push("");
+        report2.push("  Breakdown:");
         for (const [area, pts] of Object.entries(score.breakdown)) {
-          report.push(`    ${area}: ${pts}`);
+          report2.push(`    ${area}: ${pts}`);
         }
-        report.push("");
-        report.push("## Recommendations");
+        report2.push("");
+        report2.push("## Recommendations");
         for (const rec of score.recommendations) {
-          report.push(`  - ${rec}`);
+          report2.push(`  - ${rec}`);
         }
         if (this.isAiwgInstalled()) {
           try {
@@ -5499,14 +5499,14 @@ var init_aiwg_health = __esm({
               encoding: "utf8",
               timeout: 15e3
             });
-            report.push("\n## AIWG Runtime Info");
-            report.push(runtimeInfo.trim());
+            report2.push("\n## AIWG Runtime Info");
+            report2.push(runtimeInfo.trim());
           } catch {
           }
         }
         return {
           success: true,
-          output: report.join("\n"),
+          output: report2.join("\n"),
           durationMs: performance.now() - start2
         };
       }
@@ -6087,41 +6087,41 @@ var init_codebase_map = __esm({
         const maxDepth = args["depth"] || 3;
         const showFiles = args["show_files"] || false;
         try {
-          const report = [];
-          report.push("# Codebase Map\n");
+          const report2 = [];
+          report2.push("# Codebase Map\n");
           const projectInfo = this.detectProjectInfo(rootDir);
           if (projectInfo.name)
-            report.push(`**Project**: ${projectInfo.name}`);
+            report2.push(`**Project**: ${projectInfo.name}`);
           if (projectInfo.description)
-            report.push(`**Description**: ${projectInfo.description}`);
+            report2.push(`**Description**: ${projectInfo.description}`);
           if (projectInfo.language)
-            report.push(`**Language**: ${projectInfo.language}`);
-          report.push("");
-          report.push("## Key Files");
+            report2.push(`**Language**: ${projectInfo.language}`);
+          report2.push("");
+          report2.push("## Key Files");
           const keyFiles = this.findKeyFiles(rootDir);
           for (const kf of keyFiles) {
-            report.push(`  ${kf}`);
+            report2.push(`  ${kf}`);
           }
-          report.push("");
-          report.push("## Directory Structure");
+          report2.push("");
+          report2.push("## Directory Structure");
           const tree2 = this.buildTree(rootDir, rootDir, 0, maxDepth, showFiles);
-          report.push(tree2);
-          report.push("");
-          report.push("## Language Breakdown");
+          report2.push(tree2);
+          report2.push("");
+          report2.push("## Language Breakdown");
           const languages = this.countLanguages(rootDir, 0, maxDepth + 1);
           const sortedLangs = [...languages.entries()].sort((a2, b) => b[1] - a2[1]);
           for (const [lang, count] of sortedLangs.slice(0, 10)) {
-            report.push(`  ${lang.padEnd(16)} ${count} file(s)`);
+            report2.push(`  ${lang.padEnd(16)} ${count} file(s)`);
           }
-          report.push("");
+          report2.push("");
           const stats = this.countStats(rootDir, 0, maxDepth + 1);
-          report.push("## Stats");
-          report.push(`  Total files: ${stats.files}`);
-          report.push(`  Total directories: ${stats.dirs}`);
-          report.push(`  Estimated lines: ${stats.estimatedLines.toLocaleString()}`);
+          report2.push("## Stats");
+          report2.push(`  Total files: ${stats.files}`);
+          report2.push(`  Total directories: ${stats.dirs}`);
+          report2.push(`  Estimated lines: ${stats.estimatedLines.toLocaleString()}`);
           return {
             success: true,
-            output: report.join("\n"),
+            output: report2.join("\n"),
             durationMs: performance.now() - start2
           };
         } catch (error) {
@@ -6528,72 +6528,72 @@ var init_git_info = __esm({
             durationMs: performance.now() - start2
           };
         }
-        const report = [];
-        report.push("# Git Info\n");
+        const report2 = [];
+        report2.push("# Git Info\n");
         const branch = this.git(repoDir, "rev-parse --abbrev-ref HEAD");
-        report.push(`**Branch**: ${branch}`);
+        report2.push(`**Branch**: ${branch}`);
         const remote = this.git(repoDir, "rev-parse --abbrev-ref @{upstream} 2>/dev/null || echo '(none)'");
-        report.push(`**Tracking**: ${remote}`);
+        report2.push(`**Tracking**: ${remote}`);
         if (remote !== "(none)") {
           const ahead = this.git(repoDir, `rev-list --count @{upstream}..HEAD 2>/dev/null || echo 0`);
           const behind = this.git(repoDir, `rev-list --count HEAD..@{upstream} 2>/dev/null || echo 0`);
-          report.push(`**Ahead/Behind**: +${ahead}/-${behind}`);
+          report2.push(`**Ahead/Behind**: +${ahead}/-${behind}`);
         }
-        report.push("");
-        report.push("## Status");
+        report2.push("");
+        report2.push("## Status");
         const status = this.git(repoDir, "status --short");
         if (status) {
           const lines = status.split("\n").filter((l2) => l2.trim());
           const staged = lines.filter((l2) => l2[0] !== " " && l2[0] !== "?").length;
           const unstaged = lines.filter((l2) => l2[1] === "M" || l2[1] === "D").length;
           const untracked = lines.filter((l2) => l2.startsWith("??")).length;
-          report.push(`  Staged: ${staged} file(s)`);
-          report.push(`  Unstaged: ${unstaged} file(s)`);
-          report.push(`  Untracked: ${untracked} file(s)`);
-          report.push("");
+          report2.push(`  Staged: ${staged} file(s)`);
+          report2.push(`  Unstaged: ${unstaged} file(s)`);
+          report2.push(`  Untracked: ${untracked} file(s)`);
+          report2.push("");
           for (const line of lines.slice(0, 30)) {
-            report.push(`  ${line}`);
+            report2.push(`  ${line}`);
           }
           if (lines.length > 30) {
-            report.push(`  ... ${lines.length - 30} more`);
+            report2.push(`  ... ${lines.length - 30} more`);
           }
         } else {
-          report.push("  Working tree clean");
+          report2.push("  Working tree clean");
         }
-        report.push("");
-        report.push("## Recent Commits");
+        report2.push("");
+        report2.push("## Recent Commits");
         const log22 = this.git(repoDir, `log --oneline -${logCount} --no-decorate`);
         if (log22) {
           for (const line of log22.split("\n").filter((l2) => l2.trim())) {
-            report.push(`  ${line}`);
+            report2.push(`  ${line}`);
           }
         } else {
-          report.push("  (no commits)");
+          report2.push("  (no commits)");
         }
-        report.push("");
+        report2.push("");
         if (showDiff) {
-          report.push("## Diff (staged + unstaged)");
+          report2.push("## Diff (staged + unstaged)");
           const diff = this.git(repoDir, "diff HEAD 2>/dev/null || git diff");
           if (diff) {
             const truncated = diff.length > 5e3 ? diff.slice(0, 5e3) + "\n... (truncated)" : diff;
-            report.push("```diff");
-            report.push(truncated);
-            report.push("```");
+            report2.push("```diff");
+            report2.push(truncated);
+            report2.push("```");
           } else {
-            report.push("  (no changes)");
+            report2.push("  (no changes)");
           }
         } else {
-          report.push("## Diff Summary");
+          report2.push("## Diff Summary");
           const diffStat = this.git(repoDir, "diff --stat HEAD 2>/dev/null || git diff --stat");
           if (diffStat) {
-            report.push(diffStat);
+            report2.push(diffStat);
           } else {
-            report.push("  (no changes)");
+            report2.push("  (no changes)");
           }
         }
         return {
           success: true,
-          output: report.join("\n"),
+          output: report2.join("\n"),
           durationMs: performance.now() - start2
         };
       }
@@ -15371,8 +15371,8 @@ async function loadTranscribeCli() {
     }).trim();
     const tcPath = join24(globalRoot, "transcribe-cli");
     if (existsSync19(join24(tcPath, "dist", "index.js"))) {
-      const { createRequire: createRequire7 } = await import("node:module");
-      const req2 = createRequire7(import.meta.url);
+      const { createRequire: createRequire8 } = await import("node:module");
+      const req2 = createRequire8(import.meta.url);
       _tcModule = req2(join24(tcPath, "dist", "index.js"));
       return _tcModule;
     }
@@ -15385,8 +15385,8 @@ async function loadTranscribeCli() {
       for (const ver of readdirSync38(nvmBase)) {
         const tcPath = join24(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
         if (existsSync19(join24(tcPath, "dist", "index.js"))) {
-          const { createRequire: createRequire7 } = await import("node:module");
-          const req2 = createRequire7(import.meta.url);
+          const { createRequire: createRequire8 } = await import("node:module");
+          const req2 = createRequire8(import.meta.url);
           _tcModule = req2(join24(tcPath, "dist", "index.js"));
           return _tcModule;
         }
@@ -228359,17 +228359,17 @@ var init_RTCPeerConnection = __esm({
       }
       getStats() {
         return new Promise((resolve43) => {
-          const report = /* @__PURE__ */ new Map();
+          const report2 = /* @__PURE__ */ new Map();
           const cp2 = __privateGet9(this, _peerConnection)?.getSelectedCandidatePair();
           const bytesSent = __privateGet9(this, _peerConnection)?.bytesSent();
           const bytesReceived = __privateGet9(this, _peerConnection)?.bytesReceived();
           const rtt = __privateGet9(this, _peerConnection)?.rtt();
           if (!cp2) {
-            return resolve43(report);
+            return resolve43(report2);
           }
           const localIdRs = getRandomString(8);
           const localId = "RTCIceCandidate_" + localIdRs;
-          report.set(localId, {
+          report2.set(localId, {
             id: localId,
             type: "local-candidate",
             timestamp: Date.now(),
@@ -228379,7 +228379,7 @@ var init_RTCPeerConnection = __esm({
           });
           const remoteIdRs = getRandomString(8);
           const remoteId = "RTCIceCandidate_" + remoteIdRs;
-          report.set(remoteId, {
+          report2.set(remoteId, {
             id: remoteId,
             type: "remote-candidate",
             timestamp: Date.now(),
@@ -228388,7 +228388,7 @@ var init_RTCPeerConnection = __esm({
             port: cp2.remote.port
           });
           const candidateId = "RTCIceCandidatePair_" + localIdRs + "_" + remoteIdRs;
-          report.set(candidateId, {
+          report2.set(candidateId, {
             id: candidateId,
             type: "candidate-pair",
             timestamp: Date.now(),
@@ -228403,7 +228403,7 @@ var init_RTCPeerConnection = __esm({
             currentRoundTripTime: rtt
           });
           const transportId = "RTCTransport_0_1";
-          report.set(transportId, {
+          report2.set(transportId, {
             id: transportId,
             timestamp: Date.now(),
             type: "transport",
@@ -228413,14 +228413,14 @@ var init_RTCPeerConnection = __esm({
             selectedCandidatePairId: candidateId,
             selectedCandidatePairChanges: 1
           });
-          report.set("P", {
+          report2.set("P", {
             id: "P",
             type: "peer-connection",
             timestamp: Date.now(),
             dataChannelsOpened: __privateGet9(this, _dataChannels).size,
             dataChannelsClosed: __privateGet9(this, _dataChannelsClosed)
           });
-          return resolve43(report);
+          return resolve43(report2);
         });
       }
       getTransceivers() {
@@ -474718,22 +474718,22 @@ var require_dist2 = __commonJS({
       return state.paths.slice(0, state.options.maxFiles);
     };
     var onlyCountsAsync = (state, error, callback$1) => {
-      report(error, callback$1, state.counts, state.options.suppressErrors);
+      report2(error, callback$1, state.counts, state.options.suppressErrors);
       return null;
     };
     var defaultAsync = (state, error, callback$1) => {
-      report(error, callback$1, state.paths, state.options.suppressErrors);
+      report2(error, callback$1, state.paths, state.options.suppressErrors);
       return null;
     };
     var limitFilesAsync = (state, error, callback$1) => {
-      report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+      report2(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
       return null;
     };
     var groupsAsync = (state, error, callback$1) => {
-      report(error, callback$1, state.groups, state.options.suppressErrors);
+      report2(error, callback$1, state.groups, state.options.suppressErrors);
       return null;
     };
-    function report(error, callback$1, output, suppressErrors) {
+    function report2(error, callback$1, output, suppressErrors) {
       if (error && !suppressErrors) callback$1(error, output);
       else callback$1(null, output);
     }
@@ -500899,10 +500899,29 @@ var init_ts_morph_parser = __esm({
 });
 
 // packages/indexer/dist/code-graph-db.js
-import Database from "better-sqlite3";
+import { createRequire as createRequire2 } from "node:module";
 import { createHash as createHash5 } from "node:crypto";
 import { mkdirSync as mkdirSync12, readFileSync as readFileSync26 } from "node:fs";
 import { join as join50, dirname as dirname14, extname as extname9 } from "node:path";
+function loadDatabaseCtor() {
+  if (_DatabaseCtor)
+    return _DatabaseCtor;
+  try {
+    const req2 = createRequire2(import.meta.url);
+    _DatabaseCtor = req2("better-sqlite3");
+    return _DatabaseCtor;
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    throw new Error(`CodeGraphDB requires the optional 'better-sqlite3' native module, but it failed to load.
+Install it manually:
+  npm i -g better-sqlite3   (matches your global open-agents-ai install)
+If the install fails, install build tools first:
+  Debian/Ubuntu: sudo apt install -y python3 build-essential
+  Fedora/RHEL:   sudo dnf install -y python3 gcc-c++ make
+  macOS:         xcode-select --install
+Underlying error: ${msg}`);
+  }
+}
 function extractFileSymbols(content, filePath) {
   const isPython = /\.py$/.test(filePath);
   const patterns = isPython ? [{ kind: "function", re: /^\s*(async\s+)?def\s+(\w+)/m }, { kind: "class", re: /^\s*class\s+(\w+)/m }] : TS_PATTERNS2;
@@ -500958,11 +500977,12 @@ function hashContent(content) {
 function detectLanguage(filePath) {
   return EXT_TO_LANG[extname9(filePath)] ?? "unknown";
 }
-var TS_PATTERNS2, EXT_TO_LANG, CodeGraphDB;
+var _DatabaseCtor, TS_PATTERNS2, EXT_TO_LANG, CodeGraphDB;
 var init_code_graph_db = __esm({
   "packages/indexer/dist/code-graph-db.js"() {
     "use strict";
     init_ts_morph_parser();
+    _DatabaseCtor = null;
     TS_PATTERNS2 = [
       { kind: "function", re: /^\s*(export\s+)?(async\s+)?function\s+(\w+)/m },
       { kind: "class", re: /^\s*(export\s+)?(abstract\s+)?class\s+(\w+)/m },
@@ -501003,6 +501023,7 @@ var init_code_graph_db = __esm({
         this.rootDir = rootDir;
         const resolvedPath = dbPath ?? join50(rootDir, ".oa", "index", "code-graph.db");
         mkdirSync12(dirname14(resolvedPath), { recursive: true });
+        const Database = loadDatabaseCtor();
         this.db = new Database(resolvedPath);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("foreign_keys = ON");
@@ -506701,9 +506722,9 @@ function _findNemotronScript() {
   return null;
 }
 function _wordSimilarity(a2, b) {
-  const tokenize4 = (s2) => new Set(s2.toLowerCase().replace(/[^a-z0-9\s']/g, " ").split(/\s+/).filter(Boolean));
-  const sa = tokenize4(a2);
-  const sb = tokenize4(b);
+  const tokenize5 = (s2) => new Set(s2.toLowerCase().replace(/[^a-z0-9\s']/g, " ").split(/\s+/).filter(Boolean));
+  const sa = tokenize5(a2);
+  const sb = tokenize5(b);
   if (sa.size === 0 && sb.size === 0)
     return 1;
   let inter = 0;
@@ -515581,12 +515602,12 @@ var init_pressure_gate = __esm({
 });
 
 // packages/memory/dist/db.js
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 function getDatabase() {
   if (_Database !== null)
     return _Database;
   try {
-    const req2 = createRequire2(import.meta.url);
+    const req2 = createRequire3(import.meta.url);
     _Database = req2("better-sqlite3");
   } catch {
     throw new Error("better-sqlite3 is not available (native module build may have failed).\nTry: npm rebuild better-sqlite3\nMemory features (SQLite) are disabled until this is resolved.");
@@ -515594,8 +515615,8 @@ function getDatabase() {
   return _Database;
 }
 function initDb(dbPath) {
-  const Database2 = getDatabase();
-  const db = new Database2(dbPath);
+  const Database = getDatabase();
+  const db = new Database(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   runMigrations(db);
@@ -516834,6 +516855,11 @@ var init_episodeStore = __esm({
     };
     EpisodeStore = class {
       db;
+      /** Read-only access to the underlying SQLite handle for cross-cutting tools
+       *  like SelfModel that need to query multiple tables atomically. */
+      getDb() {
+        return this.db;
+      }
       /** WO-AM-05: Optional TemporalGraph for Zettelkasten auto-linking */
       graph = null;
       /** WO-AM-05: Zettelkasten config for neighbor linking */
@@ -519874,6 +519900,1173 @@ var init_crl = __esm({
   }
 });
 
+// packages/memory/dist/homeostaticRegulation.js
+function clamp(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function sanitizeEmotionalState(raw) {
+  if (!raw)
+    return { valence: 0, arousal: 0 };
+  return {
+    valence: clampValence(raw.valence ?? 0),
+    arousal: clampArousal(raw.arousal ?? 0),
+    emotion: typeof raw.emotion === "string" ? raw.emotion : void 0
+  };
+}
+function importanceMultiplier(state, tuning = DEFAULT_ENCODING) {
+  const v = clampValence(state.valence);
+  const a2 = clampArousal(state.arousal);
+  const valenceBoost = Math.max(0, v) * tuning.valenceWeight;
+  const arousalBoost = a2 * tuning.arousalWeight;
+  const raw = 1 + valenceBoost + arousalBoost;
+  return Math.min(raw, tuning.maxMultiplier);
+}
+function modulateImportance(baseImportance, state, tuning = DEFAULT_ENCODING) {
+  if (!state)
+    return baseImportance;
+  const mult = importanceMultiplier(state, tuning);
+  const adjusted = baseImportance * mult;
+  if (adjusted < 0)
+    return 0;
+  if (adjusted > 10)
+    return 10;
+  return adjusted;
+}
+function congruenceMultiplier(current, memory, tuning = DEFAULT_RETRIEVAL) {
+  const valenceDist = Math.abs(clampValence(current.valence) - clampValence(memory.valence));
+  const arousalDist = Math.abs(clampArousal(current.arousal) - clampArousal(memory.arousal));
+  const valenceSim = 1 - valenceDist / 2;
+  const arousalSim = 1 - arousalDist;
+  const valenceBonus = (valenceSim - 0.5) * tuning.valenceCongruence;
+  const arousalBonus = (arousalSim - 0.5) * tuning.arousalCongruence;
+  return 1 + valenceBonus + arousalBonus;
+}
+function modulateRetrievalScore(baseScore, current, memory, tuning = DEFAULT_RETRIEVAL) {
+  if (!current || !memory)
+    return baseScore;
+  return baseScore * congruenceMultiplier(current, memory, tuning);
+}
+function createHomeostaticState(initial, target = DEFAULT_TARGET, windowSize = DEFAULT_WINDOW) {
+  const current = sanitizeEmotionalState(initial ?? { valence: 0, arousal: 0 });
+  return {
+    current,
+    streak: 1,
+    target: sanitizeEmotionalState(target),
+    recent: [current],
+    windowSize: Math.max(1, Math.floor(windowSize))
+  };
+}
+function inSameBand(a2, b) {
+  return Math.abs(clampValence(a2.valence) - clampValence(b.valence)) < STREAK_TOLERANCE && Math.abs(clampArousal(a2.arousal) - clampArousal(b.arousal)) < STREAK_TOLERANCE;
+}
+function observeEmotionalState(prev, next) {
+  const sample = sanitizeEmotionalState(next);
+  const continued = inSameBand(prev.current, sample);
+  const recent = [sample, ...prev.recent].slice(0, prev.windowSize);
+  return {
+    ...prev,
+    current: sample,
+    streak: continued ? prev.streak + 1 : 1,
+    recent
+  };
+}
+function deviationFromTarget(state) {
+  const dv = clampValence(state.current.valence) - clampValence(state.target.valence);
+  const da = clampArousal(state.current.arousal) - clampArousal(state.target.arousal);
+  return Math.sqrt(dv * dv + da * da);
+}
+function suggestRegulation(state) {
+  const dv = clampValence(state.current.valence) - clampValence(state.target.valence);
+  const da = clampArousal(state.current.arousal) - clampArousal(state.target.arousal);
+  const NEAR = 0.15;
+  if (Math.abs(dv) < NEAR && Math.abs(da) < NEAR)
+    return null;
+  if (state.streak > 8 && Math.abs(dv) >= NEAR) {
+    return dv < 0 ? "seek-positive-experience" : "introduce-novelty";
+  }
+  if (da > NEAR && state.current.arousal > 0.85)
+    return "calming-activity";
+  if (da < -NEAR && state.current.arousal < 0.15)
+    return "energizing-activity";
+  if (dv < -NEAR)
+    return "self-compassion";
+  if (dv > NEAR)
+    return "anchor-attention";
+  return null;
+}
+var DEFAULT_ENCODING, DEFAULT_RETRIEVAL, clampValence, clampArousal, DEFAULT_TARGET, DEFAULT_WINDOW, STREAK_TOLERANCE;
+var init_homeostaticRegulation = __esm({
+  "packages/memory/dist/homeostaticRegulation.js"() {
+    "use strict";
+    DEFAULT_ENCODING = {
+      valenceWeight: 0.3,
+      arousalWeight: 0.2,
+      maxMultiplier: 1.5
+    };
+    DEFAULT_RETRIEVAL = {
+      valenceCongruence: 0.5,
+      arousalCongruence: 0.3
+    };
+    clampValence = (v) => clamp(v, -1, 1);
+    clampArousal = (a2) => clamp(a2, 0, 1);
+    DEFAULT_TARGET = { valence: 0.2, arousal: 0.4 };
+    DEFAULT_WINDOW = 16;
+    STREAK_TOLERANCE = 0.15;
+  }
+});
+
+// packages/memory/dist/selfModel.js
+var ConfidenceTracker, MODALITIES, DECAY_CLASSES, DEFAULT_OPTIONS, SelfModel;
+var init_selfModel = __esm({
+  "packages/memory/dist/selfModel.js"() {
+    "use strict";
+    init_episodeStore();
+    ConfidenceTracker = class {
+      windowSize;
+      samples = [];
+      constructor(windowSize = 200) {
+        this.windowSize = windowSize;
+        if (this.windowSize <= 0)
+          throw new Error("windowSize must be > 0");
+      }
+      record(sample) {
+        this.samples.push(sample);
+        if (this.samples.length > this.windowSize) {
+          this.samples.splice(0, this.samples.length - this.windowSize);
+        }
+      }
+      size() {
+        return this.samples.length;
+      }
+      /** Compute calibration statistics. Empty samples → neutral (0.5/0.5/0). */
+      compute() {
+        const n2 = this.samples.length;
+        if (n2 === 0) {
+          return {
+            averageConfidence: 0.5,
+            actualAccuracy: 0.5,
+            calibrationGap: 0,
+            byDomain: {},
+            sampleCount: 0
+          };
+        }
+        let sumConf = 0;
+        let sumCorrect = 0;
+        const byDomain2 = /* @__PURE__ */ new Map();
+        for (const s2 of this.samples) {
+          sumConf += s2.stated;
+          if (s2.correct)
+            sumCorrect++;
+          if (s2.domain) {
+            const d2 = byDomain2.get(s2.domain) ?? { conf: 0, correct: 0, n: 0 };
+            d2.conf += s2.stated;
+            d2.correct += s2.correct ? 1 : 0;
+            d2.n += 1;
+            byDomain2.set(s2.domain, d2);
+          }
+        }
+        const avgConf = sumConf / n2;
+        const acc = sumCorrect / n2;
+        const byDomainOut = {};
+        for (const [name10, d2] of byDomain2) {
+          byDomainOut[name10] = {
+            confidence: d2.conf / d2.n,
+            accuracy: d2.correct / d2.n,
+            n: d2.n
+          };
+        }
+        return {
+          averageConfidence: avgConf,
+          actualAccuracy: acc,
+          calibrationGap: avgConf - acc,
+          byDomain: byDomainOut,
+          sampleCount: n2
+        };
+      }
+    };
+    MODALITIES = [
+      "tool_call",
+      "tool_result",
+      "visual",
+      "audio",
+      "code",
+      "social",
+      "spatial",
+      "text",
+      "reflection",
+      "gist"
+    ];
+    DECAY_CLASSES = ["session", "daily", "procedural", "permanent"];
+    DEFAULT_OPTIONS = {
+      importanceBands: { low: 3, medium: 6, high: 8, critical: 10 },
+      approachingDecayFrac: 0.25,
+      proceduralWeakness: 0.5
+    };
+    SelfModel = class {
+      db;
+      tracker;
+      opts;
+      constructor(db, tracker = new ConfidenceTracker(), options2 = {}) {
+        this.db = db;
+        this.tracker = tracker;
+        this.opts = { ...DEFAULT_OPTIONS, ...options2 };
+      }
+      computeStats() {
+        const total = this.scalarCount("SELECT COUNT(*) AS c FROM episodes");
+        const byModality = this.bucketCount("modality", MODALITIES);
+        const byDecayClass = this.bucketCount("decay_class", DECAY_CLASSES);
+        const byImportance = this.importanceBuckets();
+        const avg = this.db.prepare("SELECT AVG(importance) AS imp, AVG(strength) AS str FROM episodes").get();
+        return {
+          totalEpisodes: total,
+          byModality,
+          byDecayClass,
+          byImportance,
+          totalKnowledgeGraphNodes: this.tableCount("kg_nodes"),
+          totalKnowledgeGraphEdges: this.tableCount("kg_edges"),
+          // Real table is `procedural_memory` (singular). Filter soft-deleted rows.
+          totalProceduralMemories: this.scalarCount("SELECT COUNT(*) AS c FROM procedural_memory WHERE deleted_at IS NULL"),
+          averageImportance: avg?.imp ?? 0,
+          averageStrength: avg?.str ?? 0
+        };
+      }
+      approachingDecay(now = Date.now()) {
+        const frac = this.opts.approachingDecayFrac;
+        const sessionCutoff = now - DECAY_TAU.session * (1 - frac);
+        const dailyCutoff = now - DECAY_TAU.daily * (1 - frac);
+        const session = this.idsByDecay("session", sessionCutoff);
+        const daily = this.idsByDecay("daily", dailyCutoff);
+        const procedural = this.weakProcedural(this.opts.proceduralWeakness);
+        return { session, daily, procedural };
+      }
+      blindSpots() {
+        const stats = this.computeStats();
+        if (stats.totalEpisodes === 0)
+          return [];
+        const expected = stats.totalEpisodes / MODALITIES.length;
+        const out = [];
+        for (const m2 of MODALITIES) {
+          const observed = stats.byModality[m2] ?? 0;
+          if (observed >= expected * 0.5)
+            continue;
+          const ratio = observed / Math.max(1, expected);
+          const severity = ratio < 0.05 ? "high" : ratio < 0.2 ? "medium" : "low";
+          out.push({ modality: m2, observed, expected, severity });
+        }
+        return out.sort((a2, b) => a2.observed - b.observed);
+      }
+      /** Compose a single snapshot — what you'd hand the agent to introspect. */
+      snapshot() {
+        return {
+          generatedAt: Date.now(),
+          stats: this.computeStats(),
+          calibration: this.tracker.compute(),
+          approachingDecay: this.approachingDecay(),
+          blindSpots: this.blindSpots()
+        };
+      }
+      // ── private helpers ────────────────────────────────────────────────────────
+      scalarCount(sql) {
+        try {
+          const row = this.db.prepare(sql).get();
+          return row?.c ?? 0;
+        } catch {
+          return 0;
+        }
+      }
+      tableCount(name10) {
+        try {
+          const row = this.db.prepare(`SELECT COUNT(*) AS c FROM ${name10}`).get();
+          return row?.c ?? 0;
+        } catch {
+          return 0;
+        }
+      }
+      bucketCount(column, keys) {
+        const out = {};
+        for (const k of keys)
+          out[k] = 0;
+        try {
+          const rows = this.db.prepare(`SELECT ${column} AS k, COUNT(*) AS c FROM episodes GROUP BY ${column}`).all();
+          for (const r2 of rows)
+            out[r2.k] = r2.c;
+        } catch {
+        }
+        return out;
+      }
+      importanceBuckets() {
+        const b = this.opts.importanceBands;
+        const safe = (n2, fallback) => Number.isFinite(n2) ? n2 : fallback;
+        const lowEnd = safe(b.low, 3) + 1;
+        const medEnd = safe(b.medium, 6) + 1;
+        const highEnd = safe(b.high, 8) + 1;
+        const critEnd = safe(b.critical, 10) + 1;
+        const q = (lo, hi) => {
+          try {
+            const row = this.db.prepare(`SELECT COUNT(*) AS c FROM episodes WHERE importance >= ? AND importance < ?`).get(lo, hi);
+            return row?.c ?? 0;
+          } catch {
+            return 0;
+          }
+        };
+        return {
+          low: q(0, lowEnd),
+          medium: q(lowEnd, medEnd),
+          high: q(medEnd, highEnd),
+          critical: q(highEnd, critEnd)
+        };
+      }
+      idsByDecay(klass, cutoff) {
+        try {
+          const rows = this.db.prepare(`SELECT id FROM episodes WHERE decay_class = ? AND timestamp <= ? ORDER BY timestamp ASC LIMIT 200`).all(klass, cutoff);
+          return rows.map((r2) => r2.id);
+        } catch {
+          return [];
+        }
+      }
+      weakProcedural(threshold) {
+        try {
+          const rows = this.db.prepare(`SELECT id FROM procedural_memory
+            WHERE deleted_at IS NULL
+              AND COALESCE(utility, 0.5) < ?
+            ORDER BY utility ASC
+            LIMIT 200`).all(threshold);
+          return rows.map((r2) => r2.id);
+        } catch {
+          return [];
+        }
+      }
+    };
+  }
+});
+
+// packages/memory/dist/predictionStore.js
+function clamp01(x) {
+  if (!Number.isFinite(x))
+    return 0.5;
+  if (x < 0)
+    return 0;
+  if (x > 1)
+    return 1;
+  return x;
+}
+function tokenSimilarity(a2, b) {
+  const tokensA = tokenize4(a2);
+  const tokensB = tokenize4(b);
+  if (tokensA.size === 0 && tokensB.size === 0)
+    return 1;
+  if (tokensA.size === 0 || tokensB.size === 0)
+    return 0;
+  let inter = 0;
+  for (const t2 of tokensA)
+    if (tokensB.has(t2))
+      inter++;
+  const union = tokensA.size + tokensB.size - inter;
+  return union > 0 ? inter / union : 0;
+}
+function tokenize4(s2) {
+  return new Set(s2.toLowerCase().split(/[^a-z0-9_]+/).filter((t2) => t2.length > 1));
+}
+function durationError(predicted, actual) {
+  if (predicted == null || actual == null)
+    return 0;
+  const safePred = Math.max(predicted, 50);
+  const ratio = Math.abs(predicted - actual) / safePred;
+  return clamp01(ratio);
+}
+var DEFAULT_AXIS_WEIGHTS, PredictionStore;
+var init_predictionStore = __esm({
+  "packages/memory/dist/predictionStore.js"() {
+    "use strict";
+    DEFAULT_AXIS_WEIGHTS = {
+      outcome: 0.4,
+      success: 0.3,
+      confidence: 0.15,
+      duration: 0.15
+    };
+    PredictionStore = class {
+      capacity;
+      axisWeights;
+      pending = /* @__PURE__ */ new Map();
+      history = [];
+      constructor(options2 = {}) {
+        this.capacity = Math.max(1, options2.capacity ?? 256);
+        this.axisWeights = { ...DEFAULT_AXIS_WEIGHTS, ...options2.axisWeights ?? {} };
+      }
+      /** Record an outgoing prediction. Replaces any prior prediction with the
+       *  same correlationId — the latest is what we'll match against. */
+      predict(p2) {
+        const sanitized = {
+          ...p2,
+          predictedConfidence: clamp01(p2.predictedConfidence),
+          predictedDuration: p2.predictedDuration != null && Number.isFinite(p2.predictedDuration) ? Math.max(0, p2.predictedDuration) : null
+        };
+        this.pending.set(p2.correlationId, sanitized);
+      }
+      /** Match an observation to a pending prediction. Returns the error or null
+       *  if no prediction was recorded for this correlationId (drop silently). */
+      observe(correlationId, observed) {
+        const pred = this.pending.get(correlationId);
+        if (!pred)
+          return null;
+        this.pending.delete(correlationId);
+        const actualDuration = observed.actualDuration != null && Number.isFinite(observed.actualDuration) ? Math.max(0, observed.actualDuration) : null;
+        const sim = tokenSimilarity(pred.predictedOutcome, observed.actualOutcome);
+        const outcomeErr = clamp01(1 - sim);
+        const successErr = pred.predictedSuccess === observed.actualSuccess ? 0 : 1;
+        const confidenceErr = clamp01(observed.actualSuccess ? 1 - pred.predictedConfidence : pred.predictedConfidence);
+        const durationErr = durationError(pred.predictedDuration, actualDuration);
+        const w = this.axisWeights;
+        const total = w.outcome * outcomeErr + w.success * successErr + w.confidence * confidenceErr + w.duration * durationErr;
+        const sumWeights = w.outcome + w.success + w.confidence + w.duration;
+        const errorMagnitude = clamp01(sumWeights > 0 ? total / sumWeights : 0);
+        const errorByAxis = {
+          outcome: outcomeErr,
+          success: successErr,
+          confidence: confidenceErr,
+          duration: durationErr
+        };
+        const dominantAxis = Object.entries(errorByAxis).reduce((best, cur) => cur[1] > best[1] ? cur : best, ["outcome", -1])[0];
+        const err = {
+          prediction: pred,
+          actualOutcome: observed.actualOutcome,
+          actualSuccess: observed.actualSuccess,
+          actualDuration,
+          observedAt: Date.now(),
+          errorMagnitude,
+          errorByAxis,
+          dominantAxis,
+          // Learning signal: large errors with high confidence drive bigger updates
+          learningSignal: clamp01(errorMagnitude * (0.5 + 0.5 * pred.predictedConfidence))
+        };
+        this.history.push(err);
+        if (this.history.length > this.capacity) {
+          this.history.splice(0, this.history.length - this.capacity);
+        }
+        return err;
+      }
+      /** All pending predictions — predictions submitted but not yet observed. */
+      pendingCount() {
+        return this.pending.size;
+      }
+      /** All recorded errors, oldest-first. */
+      getHistory() {
+        return [...this.history];
+      }
+      /** Average error magnitude over the last N samples. Useful for self-model. */
+      averageError(lastN) {
+        if (this.history.length === 0)
+          return 0;
+        const slice2 = lastN ? this.history.slice(-lastN) : this.history;
+        return slice2.reduce((s2, e2) => s2 + e2.errorMagnitude, 0) / slice2.length;
+      }
+      /** Current per-axis bias — points at the axis we're systematically wrong on. */
+      axisProfile(lastN) {
+        const slice2 = lastN ? this.history.slice(-lastN) : this.history;
+        const out = { outcome: 0, success: 0, confidence: 0, duration: 0 };
+        if (slice2.length === 0)
+          return out;
+        for (const e2 of slice2) {
+          out.outcome += e2.errorByAxis.outcome;
+          out.success += e2.errorByAxis.success;
+          out.confidence += e2.errorByAxis.confidence;
+          out.duration += e2.errorByAxis.duration;
+        }
+        out.outcome /= slice2.length;
+        out.success /= slice2.length;
+        out.confidence /= slice2.length;
+        out.duration /= slice2.length;
+        return out;
+      }
+      /** Drop everything — useful between sessions / on context switch. */
+      clear() {
+        this.pending.clear();
+        this.history.length = 0;
+      }
+    };
+  }
+});
+
+// packages/memory/dist/embodiedTrace.js
+function clamp2(x, lo, hi) {
+  if (!Number.isFinite(x))
+    return (lo + hi) / 2;
+  if (x < lo)
+    return lo;
+  if (x > hi)
+    return hi;
+  return x;
+}
+function clamp012(x) {
+  return clamp2(x, 0, 1);
+}
+function nonNegative(x) {
+  if (!Number.isFinite(x) || x < 0)
+    return 0;
+  return x;
+}
+function buildTrace(input) {
+  const i2 = input ?? {};
+  const used = nonNegative(i2.contextTokensUsed ?? DEFAULT_TRACE.contextTokensUsed);
+  const max = nonNegative(i2.contextTokensMax ?? DEFAULT_TRACE.contextTokensMax);
+  const derivedLoad = max > 0 ? used / max : 0;
+  const load2 = i2.cognitiveLoad != null ? clamp012(i2.cognitiveLoad) : clamp012(derivedLoad);
+  return {
+    durationMs: nonNegative(i2.durationMs ?? DEFAULT_TRACE.durationMs),
+    hesitationCount: Math.max(0, Math.floor(i2.hesitationCount ?? 0)),
+    retryCount: Math.max(0, Math.floor(i2.retryCount ?? 0)),
+    intensity: clamp012(i2.intensity ?? DEFAULT_TRACE.intensity),
+    visualGist: typeof i2.visualGist === "string" ? i2.visualGist : void 0,
+    auditoryGist: typeof i2.auditoryGist === "string" ? i2.auditoryGist : void 0,
+    screenState: typeof i2.screenState === "string" ? i2.screenState : void 0,
+    confidence: clamp012(i2.confidence ?? DEFAULT_TRACE.confidence),
+    cognitiveLoad: load2,
+    contextTokensUsed: used,
+    contextTokensMax: max,
+    affect: sanitizeEmotionalState(i2.affect ?? NEUTRAL_AFFECT),
+    timeOfDay: clamp2(Math.floor(i2.timeOfDay ?? DEFAULT_TRACE.timeOfDay), 0, 23),
+    sessionDurationMin: nonNegative(i2.sessionDurationMin ?? 0),
+    consecutiveActions: Math.max(0, Math.floor(i2.consecutiveActions ?? 0))
+  };
+}
+function attachTrace(metadata, trace) {
+  return { ...metadata ?? {}, [EMBODIED_KEY]: trace };
+}
+function extractTrace(metadata) {
+  if (!metadata || typeof metadata !== "object")
+    return null;
+  const raw = metadata[EMBODIED_KEY];
+  if (!raw || typeof raw !== "object")
+    return null;
+  return buildTrace(raw);
+}
+function engagementScore(trace) {
+  const alertness = 1 - trace.cognitiveLoad;
+  return clamp012((trace.intensity + alertness + trace.confidence) / 3);
+}
+function wasHesitant(trace, threshold = 0.4) {
+  return trace.hesitationCount >= 2 || trace.retryCount >= 1 || trace.confidence < threshold;
+}
+var NEUTRAL_AFFECT, DEFAULT_TRACE, EMBODIED_KEY;
+var init_embodiedTrace = __esm({
+  "packages/memory/dist/embodiedTrace.js"() {
+    "use strict";
+    init_homeostaticRegulation();
+    NEUTRAL_AFFECT = { valence: 0, arousal: 0 };
+    DEFAULT_TRACE = {
+      durationMs: 0,
+      hesitationCount: 0,
+      retryCount: 0,
+      intensity: 0,
+      confidence: 0.5,
+      cognitiveLoad: 0,
+      contextTokensUsed: 0,
+      contextTokensMax: 0,
+      affect: NEUTRAL_AFFECT,
+      timeOfDay: 0,
+      sessionDurationMin: 0,
+      consecutiveActions: 0
+    };
+    EMBODIED_KEY = "embodiedTrace";
+  }
+});
+
+// packages/memory/dist/sleepConsolidation.js
+function slowWaveReplay(db, options2 = {}) {
+  const topK = options2.topK ?? 20;
+  const lookback = options2.lookbackMs ?? 2 * 60 * 60 * 1e3;
+  const minImp = options2.minImportance ?? 6;
+  const delta = options2.strengthDelta ?? 1;
+  const start2 = Date.now();
+  const cutoff = start2 - lookback;
+  let rows = [];
+  try {
+    rows = db.prepare(`SELECT id FROM episodes
+           WHERE importance >= ?
+             AND timestamp >= ?
+           ORDER BY importance DESC, timestamp DESC
+           LIMIT ?`).all(minImp, cutoff, topK);
+  } catch {
+    rows = [];
+  }
+  if (rows.length === 0) {
+    return {
+      cycle: emptyCycle("slow_wave", start2)
+    };
+  }
+  const ids = rows.map((r2) => r2.id);
+  const placeholders = ids.map(() => "?").join(",");
+  const safeDelta = Number.isFinite(delta) ? delta : 1;
+  try {
+    db.prepare(`UPDATE episodes
+          SET strength = COALESCE(strength, 1) + ?,
+              last_retrieved = ?
+        WHERE id IN (${placeholders})`).run(safeDelta, start2, ...ids);
+  } catch {
+  }
+  return {
+    cycle: {
+      phase: "slow_wave",
+      startTime: start2,
+      endTime: Date.now(),
+      replayedEpisodes: ids,
+      downscaledEpisodes: [],
+      prunedEpisodes: [],
+      novelAssociations: [],
+      energyCost: ids.length
+    }
+  };
+}
+function remDream(db, options2 = {}) {
+  const seeds = Math.max(1, options2.seeds ?? 8);
+  const start2 = Date.now();
+  const novel = [];
+  let seedRows = [];
+  try {
+    seedRows = db.prepare(`SELECT id FROM episodes
+           WHERE importance >= 4
+           ORDER BY importance * COALESCE(strength, 1) DESC, RANDOM()
+           LIMIT ?`).all(seeds);
+  } catch {
+    seedRows = [];
+  }
+  if (seedRows.length === 0) {
+    return { cycle: emptyCycle("rem", start2) };
+  }
+  const walkDepth = Math.max(1, options2.walkDepth ?? 3);
+  for (const seed of seedRows) {
+    let temporalNeighbors = [];
+    try {
+      temporalNeighbors = db.prepare(`SELECT id FROM episodes
+             WHERE session_id IS (SELECT session_id FROM episodes WHERE id = ?)
+               AND id != ?
+             ORDER BY timestamp DESC
+             LIMIT 100`).all(seed.id, seed.id);
+    } catch {
+      continue;
+    }
+    if (temporalNeighbors.length > walkDepth) {
+      const target = temporalNeighbors[walkDepth];
+      if (target)
+        novel.push({ from: seed.id, to: target.id, reason: "rem-temporal-distance" });
+    }
+  }
+  return {
+    cycle: {
+      phase: "rem",
+      startTime: start2,
+      endTime: Date.now(),
+      replayedEpisodes: seedRows.map((r2) => r2.id),
+      downscaledEpisodes: [],
+      prunedEpisodes: [],
+      novelAssociations: novel,
+      energyCost: seedRows.length + novel.length
+    }
+  };
+}
+function lightSleep(db, options2 = {}) {
+  const start2 = Date.now();
+  const downThreshold = options2.downscaleThreshold ?? 0.3;
+  const downDelta = options2.downscaleDelta ?? 0.1;
+  const pruneImportance = options2.pruneImportanceCeiling ?? 2;
+  const maxPrune = Math.max(0, options2.maxPrune ?? 200);
+  const prunableClasses = options2.prunableClasses ?? ["session", "daily"];
+  const stalePerClass = {};
+  for (const c9 of prunableClasses) {
+    stalePerClass[c9] = options2.pruneStaleAfterMs ?? DECAY_TAU[c9] * 2;
+  }
+  let downscaled = [];
+  try {
+    downscaled = db.prepare(`SELECT id FROM episodes
+           WHERE COALESCE(strength, 1) < ?
+           ORDER BY strength ASC
+           LIMIT 500`).all(downThreshold);
+    if (downscaled.length > 0) {
+      const placeholders = downscaled.map(() => "?").join(",");
+      const safeDelta = Number.isFinite(downDelta) ? downDelta : 0.1;
+      db.prepare(`UPDATE episodes
+            SET strength = MAX(0.05, COALESCE(strength, 1) - ?)
+          WHERE id IN (${placeholders})`).run(safeDelta, ...downscaled.map((r2) => r2.id));
+    }
+  } catch {
+  }
+  const pruned = [];
+  for (const klass of prunableClasses) {
+    const stale = stalePerClass[klass];
+    const cutoff = start2 - stale;
+    let rows = [];
+    try {
+      rows = db.prepare(`SELECT id FROM episodes
+             WHERE decay_class = ?
+               AND importance < ?
+               AND timestamp < ?
+             ORDER BY timestamp ASC
+             LIMIT ?`).all(klass, pruneImportance, cutoff, maxPrune - pruned.length);
+    } catch {
+      rows = [];
+    }
+    if (rows.length === 0)
+      continue;
+    const ids = rows.map((r2) => r2.id);
+    try {
+      const placeholders = ids.map(() => "?").join(",");
+      db.prepare(`DELETE FROM episodes WHERE id IN (${placeholders})`).run(...ids);
+      pruned.push(...ids);
+    } catch {
+    }
+    if (pruned.length >= maxPrune)
+      break;
+  }
+  return {
+    cycle: {
+      phase: "light",
+      startTime: start2,
+      endTime: Date.now(),
+      replayedEpisodes: [],
+      downscaledEpisodes: downscaled.map((r2) => r2.id),
+      prunedEpisodes: pruned,
+      novelAssociations: [],
+      energyCost: downscaled.length + pruned.length
+    }
+  };
+}
+function runConsolidationCycle(db, opts = {}) {
+  const slow = slowWaveReplay(db, opts.slowWave).cycle;
+  const rem = remDream(db, opts.rem).cycle;
+  const light = lightSleep(db, opts.light).cycle;
+  return {
+    slowWave: slow,
+    rem,
+    light,
+    totalEnergy: slow.energyCost + rem.energyCost + light.energyCost
+  };
+}
+function emptyCycle(phase, start2) {
+  return {
+    phase,
+    startTime: start2,
+    endTime: Date.now(),
+    replayedEpisodes: [],
+    downscaledEpisodes: [],
+    prunedEpisodes: [],
+    novelAssociations: [],
+    energyCost: 0
+  };
+}
+function episodeCount(db) {
+  try {
+    const row = db.prepare(`SELECT COUNT(*) AS c FROM episodes`).get();
+    return row?.c ?? 0;
+  } catch {
+    return 0;
+  }
+}
+var init_sleepConsolidation = __esm({
+  "packages/memory/dist/sleepConsolidation.js"() {
+    "use strict";
+    init_episodeStore();
+  }
+});
+
+// packages/memory/dist/socialMemory.js
+import { randomUUID as randomUUID11 } from "node:crypto";
+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 clampSigned(x) {
+  return clamp3(x, -1, 1);
+}
+function sanitizeBig5(p2) {
+  return {
+    openness: clamp013(p2?.openness ?? NEUTRAL_BIG5.openness),
+    conscientiousness: clamp013(p2?.conscientiousness ?? NEUTRAL_BIG5.conscientiousness),
+    extraversion: clamp013(p2?.extraversion ?? NEUTRAL_BIG5.extraversion),
+    agreeableness: clamp013(p2?.agreeableness ?? NEUTRAL_BIG5.agreeableness),
+    neuroticism: clamp013(p2?.neuroticism ?? NEUTRAL_BIG5.neuroticism)
+  };
+}
+function pairKey(a2, b) {
+  return a2 <= b ? { lo: a2, hi: b } : { lo: b, hi: a2 };
+}
+function rowToAgent(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    type: row.type,
+    firstMet: row.first_met,
+    lastInteraction: row.last_interaction,
+    interactionCount: row.interaction_count,
+    personality: sanitizeBig5(JSON.parse(row.personality)),
+    trust: JSON.parse(row.trust),
+    metadata: row.metadata ? JSON.parse(row.metadata) : null
+  };
+}
+function rowToRelationship(row) {
+  return {
+    agentA: row.agent_a,
+    agentB: row.agent_b,
+    strength: row.strength,
+    valence: row.valence,
+    reciprocity: row.reciprocity,
+    lastUpdated: row.last_updated,
+    history: JSON.parse(row.history ?? "[]")
+  };
+}
+function rowToLesson(row) {
+  return {
+    id: row.id,
+    sourceAgent: row.source_agent,
+    lesson: row.lesson,
+    confidence: row.confidence,
+    adopted: row.adopted === 1,
+    timestamp: row.timestamp
+  };
+}
+var NEUTRAL_BIG5, SocialMemoryStore;
+var init_socialMemory = __esm({
+  "packages/memory/dist/socialMemory.js"() {
+    "use strict";
+    NEUTRAL_BIG5 = {
+      openness: 0.5,
+      conscientiousness: 0.5,
+      extraversion: 0.5,
+      agreeableness: 0.5,
+      neuroticism: 0.5
+    };
+    SocialMemoryStore = class {
+      db;
+      constructor(db) {
+        this.db = db;
+        this.initSchema();
+      }
+      initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS social_agents (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        first_met INTEGER NOT NULL,
+        last_interaction INTEGER NOT NULL,
+        interaction_count INTEGER NOT NULL DEFAULT 0,
+        personality TEXT NOT NULL,
+        trust TEXT NOT NULL,
+        metadata TEXT
+      );
+      CREATE TABLE IF NOT EXISTS social_relationships (
+        agent_a TEXT NOT NULL,
+        agent_b TEXT NOT NULL,
+        strength REAL NOT NULL DEFAULT 0,
+        valence REAL NOT NULL DEFAULT 0,
+        reciprocity REAL NOT NULL DEFAULT 0.5,
+        last_updated INTEGER NOT NULL,
+        history TEXT NOT NULL DEFAULT '[]',
+        PRIMARY KEY (agent_a, agent_b)
+      );
+      CREATE TABLE IF NOT EXISTS social_lessons (
+        id TEXT PRIMARY KEY,
+        source_agent TEXT NOT NULL,
+        lesson TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        adopted INTEGER NOT NULL DEFAULT 0,
+        timestamp INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_lessons_source ON social_lessons(source_agent);
+      CREATE INDEX IF NOT EXISTS idx_rels_agent_a ON social_relationships(agent_a);
+      CREATE INDEX IF NOT EXISTS idx_rels_agent_b ON social_relationships(agent_b);
+    `);
+      }
+      // ── Agent profiles ────────────────────────────────────────────────────────
+      upsertAgent(input) {
+        const now = Date.now();
+        const id = input.id ?? randomUUID11();
+        const existing = this.getAgent(id);
+        const personality = sanitizeBig5({ ...existing?.personality ?? {}, ...input.personality ?? {} });
+        const trustOverall = clamp013(input.trust?.overall ?? existing?.trust.overall ?? 0.5);
+        const trustByDomain = {
+          ...existing?.trust.byDomain ?? {},
+          ...input.trust?.byDomain ?? {}
+        };
+        for (const k of Object.keys(trustByDomain))
+          trustByDomain[k] = clamp013(trustByDomain[k]);
+        const metadata = input.metadata ?? existing?.metadata ?? null;
+        if (existing) {
+          this.db.prepare(`UPDATE social_agents
+              SET name = ?, type = ?, last_interaction = ?,
+                  personality = ?, trust = ?, metadata = ?
+            WHERE id = ?`).run(input.name, input.type ?? existing.type, now, JSON.stringify(personality), JSON.stringify({ overall: trustOverall, byDomain: trustByDomain }), metadata ? JSON.stringify(metadata) : null, id);
+        } else {
+          this.db.prepare(`INSERT INTO social_agents
+             (id, name, type, first_met, last_interaction, interaction_count, personality, trust, metadata)
+           VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?)`).run(id, input.name, input.type ?? "agent", now, now, JSON.stringify(personality), JSON.stringify({ overall: trustOverall, byDomain: trustByDomain }), metadata ? JSON.stringify(metadata) : null);
+        }
+        return this.getAgent(id);
+      }
+      getAgent(id) {
+        const row = this.db.prepare(`SELECT * FROM social_agents WHERE id = ?`).get(id);
+        if (!row)
+          return null;
+        return rowToAgent(row);
+      }
+      listAgents() {
+        const rows = this.db.prepare(`SELECT * FROM social_agents ORDER BY last_interaction DESC`).all();
+        return rows.map(rowToAgent);
+      }
+      updateAgent(id, update2) {
+        if (!this.getAgent(id))
+          return null;
+        return this.upsertAgent({
+          id,
+          name: update2.name ?? this.getAgent(id).name,
+          type: this.getAgent(id).type,
+          personality: update2.personality,
+          trust: update2.trust,
+          metadata: update2.metadata
+        });
+      }
+      recordInteraction(agentId, interaction) {
+        const agent = this.getAgent(agentId);
+        if (!agent)
+          return null;
+        const weight = clamp013(interaction.weight ?? 0.1);
+        const targetOverall = interaction.positive ? 1 : 0;
+        const newOverall = clamp013(agent.trust.overall + (targetOverall - agent.trust.overall) * weight);
+        const newByDomain = { ...agent.trust.byDomain };
+        if (interaction.domain) {
+          const cur = newByDomain[interaction.domain] ?? 0.5;
+          newByDomain[interaction.domain] = clamp013(cur + (targetOverall - cur) * weight);
+        }
+        const now = Date.now();
+        this.db.prepare(`UPDATE social_agents
+            SET interaction_count = interaction_count + 1,
+                last_interaction = ?,
+                trust = ?
+          WHERE id = ?`).run(now, JSON.stringify({ overall: newOverall, byDomain: newByDomain }), agentId);
+        return this.getAgent(agentId);
+      }
+      // ── Relationships ─────────────────────────────────────────────────────────
+      recordRelationshipEvent(agentA, agentB, event) {
+        if (agentA === agentB)
+          throw new Error("agentA and agentB must differ");
+        const { lo, hi } = pairKey(agentA, agentB);
+        const now = Date.now();
+        const existing = this.db.prepare(`SELECT * FROM social_relationships WHERE agent_a = ? AND agent_b = ?`).get(lo, hi);
+        const dStrength = clampSigned(event.impactOnStrength);
+        const dValence = clampSigned(event.impactOnValence);
+        const newEvent = {
+          timestamp: now,
+          event: event.event,
+          impactOnStrength: dStrength,
+          impactOnValence: dValence
+        };
+        if (existing) {
+          const history = JSON.parse(existing.history ?? "[]");
+          history.push(newEvent);
+          if (history.length > 200)
+            history.splice(0, history.length - 200);
+          const strength = clamp013(existing.strength + Math.abs(dStrength));
+          const valence = clampSigned(existing.valence + dValence);
+          const reciprocity = clamp013(existing.reciprocity * 0.95 + 0.05 * 0.5);
+          this.db.prepare(`UPDATE social_relationships
+              SET strength = ?, valence = ?, reciprocity = ?, last_updated = ?, history = ?
+            WHERE agent_a = ? AND agent_b = ?`).run(strength, valence, reciprocity, now, JSON.stringify(history), lo, hi);
+        } else {
+          const strength = clamp013(Math.abs(dStrength));
+          const valence = clampSigned(dValence);
+          this.db.prepare(`INSERT INTO social_relationships
+             (agent_a, agent_b, strength, valence, reciprocity, last_updated, history)
+           VALUES (?, ?, ?, ?, 0.5, ?, ?)`).run(lo, hi, strength, valence, now, JSON.stringify([newEvent]));
+        }
+        return this.getRelationship(agentA, agentB);
+      }
+      getRelationship(agentA, agentB) {
+        const { lo, hi } = pairKey(agentA, agentB);
+        const row = this.db.prepare(`SELECT * FROM social_relationships WHERE agent_a = ? AND agent_b = ?`).get(lo, hi);
+        if (!row)
+          return null;
+        return rowToRelationship(row);
+      }
+      listRelationshipsFor(agent) {
+        const rows = this.db.prepare(`SELECT * FROM social_relationships WHERE agent_a = ? OR agent_b = ?`).all(agent, agent);
+        return rows.map(rowToRelationship);
+      }
+      // ── Social lessons ────────────────────────────────────────────────────────
+      recordLesson(input) {
+        const id = randomUUID11();
+        const now = Date.now();
+        const conf = clamp013(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);
+        return { id, sourceAgent: input.sourceAgent, lesson: input.lesson, confidence: conf, adopted: !!adopted, timestamp: now };
+      }
+      adoptLesson(id) {
+        const r2 = this.db.prepare(`UPDATE social_lessons SET adopted = 1 WHERE id = ?`).run(id);
+        return (r2.changes ?? 0) > 0;
+      }
+      listLessons(sourceAgent) {
+        const rows = sourceAgent ? this.db.prepare(`SELECT * FROM social_lessons WHERE source_agent = ? ORDER BY timestamp DESC`).all(sourceAgent) : this.db.prepare(`SELECT * FROM social_lessons ORDER BY timestamp DESC`).all();
+        return rows.map(rowToLesson);
+      }
+    };
+  }
+});
+
+// packages/memory/dist/developmentalStage.js
+function meetsGate(m2, g) {
+  return m2.sessionCount >= g.minSessions && m2.recentPredictionError <= g.maxRecentError && m2.crossDomainLinks >= g.minCrossDomain && m2.totalEpisodes >= g.minTotalEpisodes;
+}
+function detectStage(metrics2) {
+  if (meetsGate(metrics2, STAGE_GATES.wisdom))
+    return "wisdom";
+  if (meetsGate(metrics2, STAGE_GATES.integration))
+    return "integration";
+  if (meetsGate(metrics2, STAGE_GATES.specialization))
+    return "specialization";
+  return "exploration";
+}
+function thresholdsForStage(stage) {
+  return { ...STAGE_THRESHOLDS[stage] };
+}
+function characteristicsForStage(stage) {
+  return { ...STAGE_CHARACTERISTICS[stage] };
+}
+function report(metrics2) {
+  const stage = detectStage(metrics2);
+  const thresholds = thresholdsForStage(stage);
+  const characteristics = characteristicsForStage(stage);
+  const nextStage = computeNextStage(stage, metrics2);
+  return { stage, metrics: metrics2, thresholds, characteristics, nextStage };
+}
+function computeNextStage(current, m2) {
+  const next = current === "exploration" ? "specialization" : current === "specialization" ? "integration" : current === "integration" ? "wisdom" : null;
+  if (!next)
+    return null;
+  const gate = STAGE_GATES[next];
+  const gates = [];
+  if (m2.sessionCount < gate.minSessions)
+    gates.push(`sessionCount ≥ ${gate.minSessions} (now ${m2.sessionCount})`);
+  if (m2.recentPredictionError > gate.maxRecentError)
+    gates.push(`recentPredictionError ≤ ${gate.maxRecentError} (now ${m2.recentPredictionError.toFixed(2)})`);
+  if (m2.crossDomainLinks < gate.minCrossDomain)
+    gates.push(`crossDomainLinks ≥ ${gate.minCrossDomain} (now ${m2.crossDomainLinks})`);
+  if (m2.totalEpisodes < gate.minTotalEpisodes)
+    gates.push(`totalEpisodes ≥ ${gate.minTotalEpisodes} (now ${m2.totalEpisodes})`);
+  return { name: next, gates };
+}
+function emptyMetrics() {
+  return {
+    sessionCount: 0,
+    domainCount: 0,
+    recentPredictionError: 1,
+    crossDomainLinks: 0,
+    totalEpisodes: 0,
+    creativeAssociationCount: 0
+  };
+}
+var STAGE_THRESHOLDS, STAGE_CHARACTERISTICS, STAGE_GATES;
+var init_developmentalStage = __esm({
+  "packages/memory/dist/developmentalStage.js"() {
+    "use strict";
+    STAGE_THRESHOLDS = {
+      exploration: {
+        importanceFloor: 2,
+        linkThreshold: 0.5,
+        // be generous with links
+        evolutionThreshold: 0.4,
+        // gist updates often
+        pruningAggressiveness: 0.1
+      },
+      specialization: {
+        importanceFloor: 4,
+        linkThreshold: 0.6,
+        evolutionThreshold: 0.55,
+        pruningAggressiveness: 0.3
+      },
+      integration: {
+        importanceFloor: 5,
+        linkThreshold: 0.65,
+        evolutionThreshold: 0.65,
+        pruningAggressiveness: 0.5
+      },
+      wisdom: {
+        importanceFloor: 6,
+        linkThreshold: 0.7,
+        evolutionThreshold: 0.7,
+        pruningAggressiveness: 0.7
+      }
+    };
+    STAGE_CHARACTERISTICS = {
+      exploration: {
+        memoryBreadth: 0.9,
+        memoryDepth: 0.3,
+        retrievalSpecificity: 0.3,
+        abstractionLevel: 0.2,
+        creativityIndex: 0.7,
+        predictionAccuracy: 0.4
+      },
+      specialization: {
+        memoryBreadth: 0.6,
+        memoryDepth: 0.6,
+        retrievalSpecificity: 0.6,
+        abstractionLevel: 0.4,
+        creativityIndex: 0.5,
+        predictionAccuracy: 0.6
+      },
+      integration: {
+        memoryBreadth: 0.7,
+        memoryDepth: 0.7,
+        retrievalSpecificity: 0.7,
+        abstractionLevel: 0.7,
+        creativityIndex: 0.7,
+        predictionAccuracy: 0.75
+      },
+      wisdom: {
+        memoryBreadth: 0.8,
+        memoryDepth: 0.8,
+        retrievalSpecificity: 0.8,
+        abstractionLevel: 0.9,
+        creativityIndex: 0.85,
+        predictionAccuracy: 0.85
+      }
+    };
+    STAGE_GATES = {
+      specialization: {
+        minSessions: 100,
+        maxRecentError: 0.5,
+        minCrossDomain: 0,
+        minTotalEpisodes: 100
+      },
+      integration: {
+        minSessions: 500,
+        maxRecentError: 0.4,
+        minCrossDomain: 20,
+        minTotalEpisodes: 1e3
+      },
+      wisdom: {
+        minSessions: 2e3,
+        maxRecentError: 0.25,
+        minCrossDomain: 100,
+        minTotalEpisodes: 5e3
+      }
+    };
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
@@ -519887,45 +521080,78 @@ __export(dist_exports2, {
   CRLParser: () => CRLParser,
   CRLTemplateResolver: () => CRLTemplateResolver,
   CRL_SYMBOLS: () => CRL_SYMBOLS,
+  ConfidenceTracker: () => ConfidenceTracker,
   DECAY_TAU: () => DECAY_TAU,
   DEFAULT_CRL_CONFIG: () => DEFAULT_CRL_CONFIG,
+  DEFAULT_ENCODING: () => DEFAULT_ENCODING,
+  DEFAULT_RETRIEVAL: () => DEFAULT_RETRIEVAL,
+  DEFAULT_TARGET: () => DEFAULT_TARGET,
   EmbeddingAligner: () => EmbeddingAligner,
   EpisodeStore: () => EpisodeStore,
   FailureStore: () => FailureStore,
   FileSummaryStore: () => FileSummaryStore,
   PatchHistoryStore: () => PatchHistoryStore,
+  PredictionStore: () => PredictionStore,
   ProceduralMemoryStore: () => ProceduralMemoryStore,
   RepoProfileStore: () => RepoProfileStore,
   SYMBOL_MEANINGS: () => SYMBOL_MEANINGS,
+  SelfModel: () => SelfModel,
+  SocialMemoryStore: () => SocialMemoryStore,
   TaskMemoryStore: () => TaskMemoryStore,
   TemporalGraph: () => TemporalGraph,
   ToolPatternStore: () => ToolPatternStore,
   ValidationStore: () => ValidationStore,
+  attachTrace: () => attachTrace,
   autoDecayClass: () => autoDecayClass,
   autoImportance: () => autoImportance,
   batchLink: () => batchLink,
+  buildTrace: () => buildTrace,
+  characteristicsForStage: () => characteristicsForStage,
   checkEmbeddingAvailable: () => checkEmbeddingAvailable,
   closeDb: () => closeDb,
   compressAndStore: () => compressAndStore,
   compressToGist: () => compressToGist,
+  congruenceMultiplier: () => congruenceMultiplier,
   cosineSimilarity: () => cosineSimilarity2,
   createCRLMemoryStore: () => createCRLMemoryStore,
+  createHomeostaticState: () => createHomeostaticState,
+  detectStage: () => detectStage,
+  developmentalReport: () => report,
+  deviationFromTarget: () => deviationFromTarget,
+  durationError: () => durationError,
+  emptyDevelopmentalMetrics: () => emptyMetrics,
+  engagementScore: () => engagementScore,
+  episodeCount: () => episodeCount,
   extractQueryEntities: () => extractQueryEntities,
+  extractTrace: () => extractTrace,
   findNeighbors: () => findNeighbors,
   generateEmbedding: () => generateEmbedding,
   generateEmbeddingBatch: () => generateEmbeddingBatch,
   getCRLConfigStore: () => getCRLConfigStore,
+  importanceMultiplier: () => importanceMultiplier,
   initDb: () => initDb,
+  lightSleep: () => lightSleep,
   linkEpisode: () => linkEpisode,
+  modulateImportance: () => modulateImportance,
+  modulateRetrievalScore: () => modulateRetrievalScore,
+  observeEmotionalState: () => observeEmotionalState,
   personalizedPageRank: () => personalizedPageRank,
+  remDream: () => remDream,
   resetCRLConfigStore: () => resetCRLConfigStore,
   retrieveByPPR: () => retrieveByPPR,
+  runConsolidationCycle: () => runConsolidationCycle,
+  sanitizeEmotionalState: () => sanitizeEmotionalState,
+  slowWaveReplay: () => slowWaveReplay,
   splanifoldCosine: () => cosine,
   splanifoldDeserialize: () => deserialize,
   splanifoldEvaluate: () => evaluate2,
   splanifoldFit: () => fit,
   splanifoldRmse: () => rmse,
-  splanifoldSerialize: () => serialize
+  splanifoldSerialize: () => serialize,
+  suggestRegulation: () => suggestRegulation,
+  thresholdsForStage: () => thresholdsForStage,
+  tokenSimilarity: () => tokenSimilarity,
+  wasHesitant: () => wasHesitant
 });
 var init_dist7 = __esm({
   "packages/memory/dist/index.js"() {
@@ -519948,6 +521174,13 @@ var init_dist7 = __esm({
     init_splanifold();
     init_embeddingAligner();
     init_crl();
+    init_homeostaticRegulation();
+    init_selfModel();
+    init_predictionStore();
+    init_embodiedTrace();
+    init_sleepConsolidation();
+    init_socialMemory();
+    init_developmentalStage();
   }
 });
 
@@ -533170,28 +534403,28 @@ function loadAgentTaskSidecars() {
   }
 }
 async function restoreAgentTasks(taskMgr) {
-  const report = { restored: 0, reAttached: 0, markedFailed: 0 };
+  const report2 = { restored: 0, reAttached: 0, markedFailed: 0 };
   const sidecars = loadAgentTaskSidecars();
   for (const task of sidecars) {
     taskMgr.adopt(task);
-    report.restored++;
+    report2.restored++;
     if (task.status === "running") {
       const pid = task.pid;
       if (pid && pid > 0) {
         try {
           process.kill(pid, 0);
-          report.reAttached++;
+          report2.reAttached++;
         } catch {
           taskMgr.fail(task.id, "Daemon restart while subprocess was still running");
-          report.markedFailed++;
+          report2.markedFailed++;
         }
       } else {
         taskMgr.fail(task.id, "Daemon restart — in-process sub-agent lost");
-        report.markedFailed++;
+        report2.markedFailed++;
       }
     }
   }
-  return report;
+  return report2;
 }
 function purgeOldSidecars(maxAgeHours = 24) {
   let purged = 0;
@@ -534341,8 +535574,8 @@ var init_listen = __esm({
       /** Load transcribe-cli — bundled as a dependency of open-agents-ai. */
       async loadTranscribeCli() {
         try {
-          const { createRequire: createRequire7 } = await import("node:module");
-          const req2 = createRequire7(import.meta.url);
+          const { createRequire: createRequire8 } = await import("node:module");
+          const req2 = createRequire8(import.meta.url);
           return req2("transcribe-cli");
         } catch {
         }
@@ -534354,8 +535587,8 @@ var init_listen = __esm({
           }).trim();
           const tcPath = join85(globalRoot, "transcribe-cli");
           if (existsSync69(join85(tcPath, "dist", "index.js"))) {
-            const { createRequire: createRequire7 } = await import("node:module");
-            const req2 = createRequire7(import.meta.url);
+            const { createRequire: createRequire8 } = await import("node:module");
+            const req2 = createRequire8(import.meta.url);
             return req2(join85(tcPath, "dist", "index.js"));
           }
         } catch {
@@ -534367,8 +535600,8 @@ var init_listen = __esm({
             for (const ver of readdirSync38(nvmBase)) {
               const tcPath = join85(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
               if (existsSync69(join85(tcPath, "dist", "index.js"))) {
-                const { createRequire: createRequire7 } = await import("node:module");
-                const req2 = createRequire7(import.meta.url);
+                const { createRequire: createRequire8 } = await import("node:module");
+                const req2 = createRequire8(import.meta.url);
                 return req2(join85(tcPath, "dist", "index.js"));
               }
             }
@@ -553676,7 +554909,7 @@ import { existsSync as existsSync80, mkdirSync as mkdirSync44, writeFileSync as
 import { join as join96, dirname as dirname30 } from "node:path";
 import { homedir as homedir30, tmpdir as tmpdir20, platform as platform4 } from "node:os";
 import { execSync as execSync50, spawn as nodeSpawn } from "node:child_process";
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 function sanitizeForTTS(text) {
   return text.replace(/^#{1,6}\s+/gm, "").replace(/\*{1,3}([^*]+)\*{1,3}/g, "$1").replace(/_{1,3}([^_]+)_{1,3}/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/```[\s\S]*?```/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1").replace(/^[\s]*[-*+]\s+/gm, "").replace(/^[\s]*\d+\.\s+/gm, "").replace(/^>\s+/gm, "").replace(/^[-*_]{3,}$/gm, "").replace(/\[[ xX]\]\s*/g, "").replace(/[\u{1F600}-\u{1F64F}]/gu, "").replace(/[\u{1F300}-\u{1F5FF}]/gu, "").replace(/[\u{1F680}-\u{1F6FF}]/gu, "").replace(/[\u{1F1E0}-\u{1F1FF}]/gu, "").replace(/[\u{2600}-\u{26FF}]/gu, "").replace(/[\u{2700}-\u{27BF}]/gu, "").replace(/[\u{FE00}-\u{FE0F}]/gu, "").replace(/[\u{1F900}-\u{1F9FF}]/gu, "").replace(/[\u{1FA00}-\u{1FA6F}]/gu, "").replace(/[\u{1FA70}-\u{1FAFF}]/gu, "").replace(/[\u{200D}]/gu, "").replace(/[\u{20E3}]/gu, "").replace(/[✓✔✗✘✕✖⚠️⏸⏹⏵●○◆◇■□▪▫►▼▲◀⬆⬇⬅➡↑↓←→⇐⇒⇑⇓]/g, "").replace(/[─━│┃┌┐└┘├┤┬┴┼╔╗╚╝╠╣╦╩╬⎿⎾▕▏⏐░▒▓█⠀-⣿]/g, "").replace(/\s{2,}/g, " ").trim();
 }
@@ -556324,7 +557557,7 @@ if __name__ == '__main__':
             dependencies: expectedDeps
           }, null, 2));
         }
-        const voiceRequire = createRequire3(join96(voiceDir(), "index.js"));
+        const voiceRequire = createRequire4(join96(voiceDir(), "index.js"));
         const probeOnnx = async () => {
           try {
             const output = await this.asyncShell(
@@ -563158,11 +564391,11 @@ async function handleUpdate(subcommand, ctx3) {
   }
   let currentVersion = "0.0.0";
   try {
-    const { createRequire: createRequire7 } = await import("node:module");
+    const { createRequire: createRequire8 } = await import("node:module");
     const { fileURLToPath: fileURLToPath20 } = await import("node:url");
     const { dirname: dirname39, join: join125 } = await import("node:path");
     const { existsSync: existsSync107 } = await import("node:fs");
-    const req2 = createRequire7(import.meta.url);
+    const req2 = createRequire8(import.meta.url);
     const thisDir = dirname39(fileURLToPath20(import.meta.url));
     const candidates = [
       join125(thisDir, "..", "package.json"),
@@ -564294,10 +565527,10 @@ var init_commands = __esm({
             return "handled";
           }
           try {
-            const { createRequire: createRequire7 } = await import("node:module");
+            const { createRequire: createRequire8 } = await import("node:module");
             const { fileURLToPath: fileURLToPath20 } = await import("node:url");
             const { dirname: pathDirname, join: pathJoin } = await import("node:path");
-            const localRequire = createRequire7(import.meta.url);
+            const localRequire = createRequire8(import.meta.url);
             const here = pathDirname(fileURLToPath20(import.meta.url));
             let version4 = "?";
             for (const up of ["..", "../..", "../../.."]) {
@@ -572912,7 +574145,7 @@ Call task_complete with a human-readable summary of the autoresearch session.`,
           onEvent
         );
         const reportPath = join105(this.dreamsDir, `cycle-${cycleNum}-autoresearch-report.md`);
-        const report = `# Autoresearch Swarm Report — Cycle ${cycleNum}
+        const report2 = `# Autoresearch Swarm Report — Cycle ${cycleNum}
 
 **Date**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
 **Rounds completed**: ${workspace.roundsCompleted}
@@ -572934,7 +574167,7 @@ ${summaryResult}
 `;
         try {
           mkdirSync51(this.dreamsDir, { recursive: true });
-          writeFileSync46(reportPath, report, "utf-8");
+          writeFileSync46(reportPath, report2, "utf-8");
         } catch {
         }
         renderSwarmComplete(workspace);
@@ -574798,7 +576031,7 @@ function appraiseEvent(event) {
       return null;
   }
 }
-function clamp(value2, min, max) {
+function clamp4(value2, min, max) {
   return Math.max(min, Math.min(max, value2));
 }
 var BASELINE_VALENCE, BASELINE_AROUSAL, DECAY_HALF_LIFE_MS, LABEL_UPDATE_INTERVAL_MS, EXCITEMENT_THRESHOLD, DISTRESS_THRESHOLD, OUTREACH_COOLDOWN_MS, OUTREACH_MIN_STREAK, LABEL_REGEN_THRESHOLD, EmotionEngine;
@@ -574936,8 +576169,8 @@ var init_emotion_engine = __esm({
         if (this.consecutiveFailures >= 2) {
           momentum = 1 + (this.consecutiveFailures - 1) * 0.25;
         }
-        this.state.valence = clamp(this.state.valence + delta.valence * momentum, -1, 1);
-        this.state.arousal = clamp(this.state.arousal + delta.arousal * momentum, 0, 1);
+        this.state.valence = clamp4(this.state.valence + delta.valence * momentum, -1, 1);
+        this.state.arousal = clamp4(this.state.arousal + delta.arousal * momentum, 0, 1);
         this.state.updatedAt = Date.now();
         const deterministicLabel = labelFromCoordinates(this.state.valence, this.state.arousal);
         this.state.label = deterministicLabel.label;
@@ -576442,7 +577675,7 @@ __export(chat_session_exports, {
   startInFlightChat: () => startInFlightChat,
   trackSessionTokens: () => trackSessionTokens
 });
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import {
   existsSync as existsSync92,
   readFileSync as readFileSync74,
@@ -576493,10 +577726,10 @@ function deleteInFlightFile(id) {
   }
 }
 function loadPersistedSessions() {
-  const report = { restored: 0, staleInFlight: 0 };
+  const report2 = { restored: 0, staleInFlight: 0 };
   try {
     const dir = sessionsDir();
-    if (!existsSync92(dir)) return report;
+    if (!existsSync92(dir)) return report2;
     const cutoff = Date.now() - SESSION_TTL_MS;
     for (const f2 of readdirSync31(dir)) {
       if (!f2.endsWith(".json") || f2.includes(".tmp.")) continue;
@@ -576515,7 +577748,7 @@ function loadPersistedSessions() {
                 writeFileSync48(fp, JSON.stringify(parsed, null, 2), "utf-8");
               } catch {
               }
-              report.staleInFlight++;
+              report2.staleInFlight++;
             }
           }
           continue;
@@ -576523,7 +577756,7 @@ function loadPersistedSessions() {
         if (parsed && typeof parsed === "object" && parsed.id) {
           if ((parsed.lastActivity ?? 0) >= cutoff) {
             sessions.set(parsed.id, parsed);
-            report.restored++;
+            report2.restored++;
           }
         }
       } catch {
@@ -576531,7 +577764,7 @@ function loadPersistedSessions() {
     }
   } catch {
   }
-  return report;
+  return report2;
 }
 function buildSystemPrompt(cwd4) {
   const parts = [];
@@ -576599,7 +577832,7 @@ function getSession(sessionId, model, cwd4) {
     } catch {
     }
   }
-  const id = sessionId || randomUUID11();
+  const id = sessionId || randomUUID12();
   const systemPrompt = buildSystemPrompt(cwd4);
   const session = {
     id,
@@ -576866,7 +578099,7 @@ __export(projects_exports, {
 import { readFileSync as readFileSync75, writeFileSync as writeFileSync49, mkdirSync as mkdirSync55, existsSync as existsSync93, statSync as statSync29, renameSync as renameSync6 } from "node:fs";
 import { homedir as homedir34 } from "node:os";
 import { basename as basename20, join as join110, resolve as resolve35 } from "node:path";
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 function readAll2() {
   try {
     if (!existsSync93(PROJECTS_FILE)) return { projects: [], schemaVersion: 1 };
@@ -576880,7 +578113,7 @@ function readAll2() {
 }
 function writeAll(file) {
   mkdirSync55(OA_DIR3, { recursive: true });
-  const tmp = `${PROJECTS_FILE}.${randomUUID12().slice(0, 8)}.tmp`;
+  const tmp = `${PROJECTS_FILE}.${randomUUID13().slice(0, 8)}.tmp`;
   writeFileSync49(tmp, JSON.stringify(file, null, 2), "utf8");
   renameSync6(tmp, PROJECTS_FILE);
 }
@@ -577673,7 +578906,7 @@ import { createHash as createHash12 } from "node:crypto";
 import { existsSync as existsSync94, mkdirSync as mkdirSync56, readFileSync as readFileSync76, renameSync as renameSync7, writeFileSync as writeFileSync50, unlinkSync as unlinkSync22 } from "node:fs";
 import { homedir as homedir35 } from "node:os";
 import { join as join111, resolve as resolve36 } from "node:path";
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 function projectKey(root) {
   const canonical = resolve36(root);
   return createHash12("sha256").update(canonical).digest("hex").slice(0, 16);
@@ -577721,7 +578954,7 @@ function writeProjectPreferences(root, partial) {
     updatedAt: Date.now()
   };
   const file = prefsPath(root);
-  const tmp = `${file}.${randomUUID13().slice(0, 8)}.tmp`;
+  const tmp = `${file}.${randomUUID14().slice(0, 8)}.tmp`;
   writeFileSync50(tmp, JSON.stringify(merged, null, 2), "utf8");
   try {
     renameSync7(tmp, file);
@@ -577768,7 +579001,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter11 } from "node:events";
-function clamp01(x) {
+function clamp014(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -577807,9 +579040,9 @@ function computeSignalFromText(text, confidence) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence === "number" && !Number.isNaN(confidence)) {
-    score = 0.7 * score + 0.3 * clamp01(confidence);
+    score = 0.7 * score + 0.3 * clamp014(confidence);
   }
-  return clamp01(score);
+  return clamp014(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -578079,7 +579312,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp01(snr) : computeSignalFromText(text, confidence);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp014(snr) : computeSignalFromText(text, confidence);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -590526,13 +591759,13 @@ __export(serve_exports, {
 });
 import * as http5 from "node:http";
 import * as https3 from "node:https";
-import { createRequire as createRequire4 } from "node:module";
+import { createRequire as createRequire5 } from "node:module";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 import { dirname as dirname36, join as join119, resolve as resolve38 } from "node:path";
 import { homedir as homedir41 } from "node:os";
 import { spawn as spawn25, execSync as execSync56 } from "node:child_process";
 import { mkdirSync as mkdirSync63, writeFileSync as writeFileSync55, readFileSync as readFileSync83, readdirSync as readdirSync35, existsSync as existsSync103, watch as fsWatch3, renameSync as renameSync8, unlinkSync as unlinkSync24 } from "node:fs";
-import { randomBytes as randomBytes23, randomUUID as randomUUID14 } from "node:crypto";
+import { randomBytes as randomBytes23, randomUUID as randomUUID15 } from "node:crypto";
 import { createHash as createHash15 } from "node:crypto";
 function getVersion3() {
   try {
@@ -593617,7 +594850,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"] || randomUUID14();
+  const requestId = req2.headers["x-request-id"] || randomUUID15();
   res.setHeader("X-Request-ID", requestId);
   res.setHeader("X-API-Version", API_VERSION);
   if (method === "OPTIONS") {
@@ -593696,8 +594929,8 @@ async function handleRequest(req2, res, ollamaUrl, verbose) {
       const entry = fileMap[pathname];
       if (entry) {
         try {
-          const { createRequire: createRequire7 } = await import("node:module");
-          const req22 = createRequire7(import.meta.url);
+          const { createRequire: createRequire8 } = await import("node:module");
+          const req22 = createRequire8(import.meta.url);
           const cssEntry = req22.resolve("swagger-ui-dist/swagger-ui.css");
           const fs7 = await import("node:fs");
           const path8 = await import("node:path");
@@ -596357,9 +597590,9 @@ function startApiServer(options2 = {}) {
     taskMgr.onEviction((taskId) => {
       deleteAgentTaskSidecar(taskId);
     });
-    restoreAgentTasks(taskMgr).then((report) => {
-      if (report.restored > 0) {
-        log22(`  task recovery: restored=${report.restored} re-attached=${report.reAttached} marked-failed=${report.markedFailed}
+    restoreAgentTasks(taskMgr).then((report2) => {
+      if (report2.restored > 0) {
+        log22(`  task recovery: restored=${report2.restored} re-attached=${report2.reAttached} marked-failed=${report2.markedFailed}
 `);
       }
     }).catch(() => {
@@ -596373,9 +597606,9 @@ function startApiServer(options2 = {}) {
   } catch {
   }
   try {
-    const report = loadPersistedSessions();
-    if (report.restored > 0 || report.staleInFlight > 0) {
-      log22(`  chat sessions: restored=${report.restored} stale-in-flight=${report.staleInFlight}
+    const report2 = loadPersistedSessions();
+    if (report2.restored > 0 || report2.staleInFlight > 0) {
+      log22(`  chat sessions: restored=${report2.restored} stale-in-flight=${report2.staleInFlight}
 `);
     }
   } catch {
@@ -597173,7 +598406,7 @@ var init_serve = __esm({
     init_profiles();
     init_docker();
     init_typed_node_events();
-    require3 = createRequire4(import.meta.url);
+    require3 = createRequire5(import.meta.url);
     endpointRegistry = [];
     modelRouteMap = /* @__PURE__ */ new Map();
     endpointUsage = /* @__PURE__ */ new Map();
@@ -597195,7 +598428,7 @@ var init_serve = __esm({
 // packages/cli/src/tui/interactive.ts
 import { cwd } from "node:process";
 import { resolve as resolve39, join as join120, dirname as dirname37, extname as extname12 } from "node:path";
-import { createRequire as createRequire5 } from "node:module";
+import { createRequire as createRequire6 } from "node:module";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
 import { readFileSync as readFileSync84, writeFileSync as writeFileSync56, appendFileSync as appendFileSync8, rmSync as rmSync5, readdirSync as readdirSync36, mkdirSync as mkdirSync64 } from "node:fs";
 import { existsSync as existsSync104 } from "node:fs";
@@ -597213,7 +598446,7 @@ function formatTimeAgo2(date) {
 }
 function getVersion4() {
   try {
-    const require4 = createRequire5(import.meta.url);
+    const require4 = createRequire6(import.meta.url);
     const thisDir = dirname37(fileURLToPath18(import.meta.url));
     const candidates = [
       join120(thisDir, "..", "package.json"),
@@ -604740,18 +605973,18 @@ async function evalCommand(opts, config) {
     const start2 = Date.now();
     let result;
     try {
-      const report = await loop.run(task.request, evalRepoRoot);
-      const passed2 = task.expectedStatuses.includes(report.status);
+      const report2 = await loop.run(task.request, evalRepoRoot);
+      const passed2 = task.expectedStatuses.includes(report2.status);
       result = {
         task,
-        status: report.status,
+        status: report2.status,
         passed: passed2,
         durationMs: Date.now() - start2
       };
       if (passed2) {
-        spinner.succeed(`[${task.id}] PASS (${report.status})`);
+        spinner.succeed(`[${task.id}] PASS (${report2.status})`);
       } else {
-        spinner.fail(`[${task.id}] FAIL (got: ${report.status})`);
+        spinner.fail(`[${task.id}] FAIL (got: ${report2.status})`);
       }
     } catch (err) {
       result = {
@@ -604863,7 +606096,7 @@ init_output();
 init_updater();
 init_typed_node_events();
 import { parseArgs as nodeParseArgs2 } from "node:util";
-import { createRequire as createRequire6 } from "node:module";
+import { createRequire as createRequire7 } from "node:module";
 import { fileURLToPath as fileURLToPath19 } from "node:url";
 import { dirname as dirname38, join as join124 } from "node:path";
 
@@ -604943,7 +606176,7 @@ function createCli(options2) {
 import { parseArgs as nodeParseArgs } from "node:util";
 
 // packages/cli/src/types.ts
-var DEFAULT_OPTIONS = {
+var DEFAULT_OPTIONS2 = {
   model: "qwen-2.5-coder-32b",
   backendUrl: "http://localhost:8000/v1",
   projectRoot: process.cwd(),
@@ -604972,12 +606205,12 @@ function parseArgs(argv) {
     process.exit(0);
   }
   return {
-    model: values.model ?? DEFAULT_OPTIONS.model,
-    backendUrl: values["backend-url"] ?? DEFAULT_OPTIONS.backendUrl,
-    projectRoot: values["project-root"] ?? DEFAULT_OPTIONS.projectRoot,
-    maxIterations: values["max-iterations"] ? parseInt(values["max-iterations"], 10) : DEFAULT_OPTIONS.maxIterations,
-    temperature: values.temperature ? parseFloat(values.temperature) : DEFAULT_OPTIONS.temperature,
-    verbose: values.verbose ?? DEFAULT_OPTIONS.verbose
+    model: values.model ?? DEFAULT_OPTIONS2.model,
+    backendUrl: values["backend-url"] ?? DEFAULT_OPTIONS2.backendUrl,
+    projectRoot: values["project-root"] ?? DEFAULT_OPTIONS2.projectRoot,
+    maxIterations: values["max-iterations"] ? parseInt(values["max-iterations"], 10) : DEFAULT_OPTIONS2.maxIterations,
+    temperature: values.temperature ? parseFloat(values.temperature) : DEFAULT_OPTIONS2.temperature,
+    verbose: values.verbose ?? DEFAULT_OPTIONS2.verbose
   };
 }
 function printHelp() {
@@ -605004,7 +606237,7 @@ init_spinner();
 init_output();
 function getVersion5() {
   try {
-    const require4 = createRequire6(import.meta.url);
+    const require4 = createRequire7(import.meta.url);
     const pkgPath = join124(dirname38(fileURLToPath19(import.meta.url)), "..", "package.json");
     const pkg = require4(pkgPath);
     return pkg.version;