nexo-brain 2.6.15 → 2.6.16

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.15",
+  "version": "2.6.16",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -38,7 +38,24 @@ That means NEXO now manages not only the shared runtime and MCP wiring, but also
 - For Codex specifically, `nexo chat` and Codex headless automation inject the current bootstrap explicitly, so Codex starts as NEXO even when plain global Codex startup is inconsistent about global instructions.
 - Deep Sleep now reads both Claude Code and Codex transcript stores, so overnight analysis still works even when the user spends the day in Codex.
 
-Version `2.6.14` closes those parity gaps in practice, and `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly.
+Version `2.6.14` closes those parity gaps in practice, `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly, and `2.6.16` pushes the system further in three directions:
+
+- Codex now gets managed global bootstrap/model sync in `~/.codex/config.toml`, so sessions opened outside `nexo chat` are much less likely to start as plain Codex.
+- Retrieval is smarter by default: HyDE and spreading activation now auto-enable when the query shape benefits, while exact lookups remain conservative.
+- Deep Sleep now blends recent context with older context over a 60-day horizon, and memory decay now tracks per-memory `stability` and `difficulty` instead of relying only on global decay constants.
+
+### Client Capability Matrix
+
+| Capability | Claude Code | Codex | Claude Desktop |
+|------------|-------------|-------|----------------|
+| Shared brain / MCP runtime | Yes | Yes | Yes |
+| Managed bootstrap document | `~/.claude/CLAUDE.md` | `~/.codex/AGENTS.md` | Not applicable |
+| Global startup bootstrap sync | Native via hooks + bootstrap | Managed via bootstrap + Codex config `initial_messages` | MCP only |
+| `nexo chat` terminal client | Yes | Yes | No |
+| Background automation backend | Recommended | Supported | No |
+| Raw transcript source for Deep Sleep | Yes | Yes | No |
+| Native hook depth | Deepest | Partial, compensated | None |
+| Recommended today | Yes | Supported | Shared-brain companion |
 
 ## The Problem
 
@@ -100,12 +117,25 @@ NEXO Brain uses **Ebbinghaus forgetting curves** — memories naturally fade ove
 - A lesson accessed 5 times in 2 weeks gets promoted to long-term memory — because repeated use proves it matters.
 - A dormant memory can be reactivated if something similar comes up — the "oh wait, I remember this" moment.
 
+On top of that baseline, NEXO now keeps a lightweight **per-memory profile**:
+
+- **stability** slows decay for memories that keep surviving retrieval and reinforcement
+- **difficulty** speeds decay slightly for memories that tend to be weak, noisy, or harder to reuse correctly
+
+That keeps the core Ebbinghaus model, but makes decay more individual and less purely global.
+
 ### Semantic Search (Finding by Meaning)
 
 NEXO Brain doesn't search by keywords. It searches by **meaning** using vector embeddings (fastembed, 768 dimensions).
 
 Example: If you search for "deploy problems", NEXO Brain will find a memory about "SSH connection timeout on production server" — even though they share zero words. This is how human associative memory works.
 
+Retrieval is now also smarter by default:
+
+- **HyDE auto mode** expands conceptual or ambiguous queries when that improves recall
+- **Spreading activation auto mode** adds a shallow associative boost for concept-heavy searches
+- **Exact lookup heuristics** keep both off for literal file paths, IDs, stack traces, and other precision-sensitive queries
+
 ### Metacognition (Thinking About Thinking)
 
 Before every code change, NEXO Brain asks itself: **"Have I made a mistake like this before?"**
@@ -156,6 +186,12 @@ Like a human brain, NEXO Brain has automated processes that run while you're not
 
 If your Mac was asleep during any scheduled process, NEXO Brain catches up in order when it wakes.
 
+Deep Sleep now also mixes **recent context with older context across a 60-day horizon**. Instead of only looking at the immediate past, it can surface:
+
+- recurring multi-week themes
+- cross-domain links between older learnings and current failures
+- stale followups and topics that keep being mentioned but never formalized
+
 ## Cognitive Cortex
 
 The Cortex is a middleware cognitive layer that makes the agent **think before acting**. It implements architectural inhibitory control — the agent cannot bypass reasoning.
@@ -235,21 +271,21 @@ NEXO Brain provides **150+ MCP tools** across 23 categories. These features impl
 |---------|-------------|
 | **Pin / Snooze / Archive** | Granular lifecycle states for memories. Pin = never decays (critical knowledge). Snooze = temporarily hidden (revisit later). Archive = cold storage (searchable but inactive). |
 | **Intelligent Chunking** | Adaptive chunking that respects sentence and paragraph boundaries. Produces semantically coherent chunks instead of arbitrary token splits, reducing retrieval noise. |
-| **Adaptive Decay** | Decay rate adapts per memory based on access patterns: frequently-accessed memories decay slower, rarely-accessed ones fade faster. Prevents permanent clutter while keeping active knowledge sharp. |
+| **Adaptive Decay** | Decay rate still follows Ebbinghaus as the base model, but now also adapts per memory using `stability` and `difficulty` profiles. Frequently reinforced memories become stickier; fragile memories fade sooner. |
 | **Auto-Migration** | Formal schema migration system (schema_migrations table) tracks all database changes. Safe, reversible schema evolution for production systems — upgrades never lose data. |
 | **Auto-Merge Duplicates** | Batch cosine deduplication during the 03:00 sleep cycle. Respects sibling discrimination — similar memories about different contexts are kept separate. |
-| **Memory Dreaming** | Discovers hidden connections between recent memories during the 03:00 sleep cycle. Surfaces non-obvious patterns like "these three bugs all relate to the same root cause." |
+| **Memory Dreaming** | Discovers hidden connections between recent memories during the 03:00 sleep cycle and now feeds a 60-day long-horizon Deep Sleep blend, so older patterns can reappear when they become relevant again. |
 
 ### Retrieval
 
 | Feature | What It Does |
 |---------|-------------|
-| **HyDE Query Expansion** | Generates hypothetical answer embeddings for richer semantic search. Instead of searching for "deploy error", it imagines what a helpful memory about deploy errors would look like, then searches for that. |
+| **HyDE Query Expansion** | Generates hypothetical answer embeddings for richer semantic search. NEXO now auto-enables HyDE for conceptual or ambiguous queries while keeping literal lookups conservative. |
 | **Hybrid Search (FTS5+BM25+RRF)** | Combines dense vector search with BM25 keyword search via Reciprocal Rank Fusion. Outperforms pure semantic search on precise terminology and code identifiers. |
 | **Cross-Encoder Reranking** | After initial vector retrieval, a cross-encoder model rescores candidates for precision. The top-k results are reordered by true semantic relevance before being returned to the agent. |
 | **Multi-Query Decomposition** | Complex questions are automatically split into sub-queries. Each component is retrieved independently, then fused for a higher-quality answer — improves recall on multi-faceted prompts. |
 | **Temporal Indexing** | Memories are indexed by time in addition to semantics. Time-sensitive queries ("what did we decide last Tuesday?") use temporal proximity scoring alongside semantic similarity. |
-| **Spreading Activation** | Graph-based co-activation network. Memories retrieved together reinforce each other's connections, building an associative web that improves over time. |
+| **Spreading Activation** | Graph-based co-activation network. NEXO now auto-enables a shallow spreading pass for concept-heavy queries, improving contextual recall without turning every exact lookup into a fuzzy search. |
 | **Recall Explanations** | Transparent score breakdown for every retrieval result. Shows exactly why a memory was returned: semantic similarity, recency, access frequency, and co-activation bonuses. |
 
 ### Proactive

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.15",
+  "version": "2.6.16",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/agent_runner.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 import json
 import os
+import shlex
 import shutil
 import subprocess
 import tempfile
+import tomllib
 from pathlib import Path
 
 from client_preferences import (
@@ -66,6 +68,10 @@ def _resolve_codex_cli() -> str:
     return shutil.which("codex") or ""
 
 
+def _codex_config_path() -> Path:
+    return Path.home() / ".codex" / "config.toml"
+
+
 def _headless_env(env: dict | None = None) -> dict:
     merged = os.environ.copy()
     if env:
@@ -84,6 +90,21 @@ def _load_client_bootstrap_prompt(client: str) -> str:
     return load_bootstrap_prompt(client, nexo_home=NEXO_HOME, user_home=Path.home())
 
 
+def _codex_managed_initial_messages_enabled() -> bool:
+    config_path = _codex_config_path()
+    if not config_path.is_file():
+        return False
+    try:
+        payload = tomllib.loads(config_path.read_text())
+    except Exception:
+        return False
+    return bool(
+        payload.get("nexo", {})
+        .get("codex", {})
+        .get("bootstrap_managed")
+    )
+
+
 def _codex_initial_messages_config(prompt_text: str) -> str:
     return f'initial_messages=[{{role="system",content={json.dumps(prompt_text, ensure_ascii=False)}}}]'
 
@@ -121,7 +142,7 @@ def build_interactive_client_command(
             )
         cmd = [codex_bin]
         bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-        if bootstrap_prompt:
+        if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
             cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
         if profile["model"]:
             cmd.extend(["-m", profile["model"]])
@@ -147,6 +168,53 @@ def launch_interactive_client(
     return subprocess.run(cmd, env=launch_env)
 
 
+def build_followup_terminal_shell_command(
+    followup_reference: str,
+    *,
+    client: str | None = None,
+    preferences: dict | None = None,
+    cwd: str | os.PathLike[str] | None = None,
+) -> tuple[str, str]:
+    prefs = preferences or load_client_preferences()
+    selected = resolve_terminal_client(client, preferences=prefs)
+    profile = resolve_client_runtime_profile(selected, preferences=prefs)
+    prompt = f"NEXO: execute followup from file $(cat {followup_reference})"
+
+    if selected == CLIENT_CLAUDE_CODE:
+        claude_bin = _resolve_claude_cli()
+        if not claude_bin:
+            raise TerminalClientUnavailableError(
+                "Claude Code launcher not found in PATH. Install `claude` first."
+            )
+        cmd = [claude_bin]
+        if profile["model"]:
+            cmd.extend(["--model", profile["model"]])
+        if profile["reasoning_effort"]:
+            cmd.extend(["--effort", profile["reasoning_effort"]])
+        cmd.extend(["--dangerously-skip-permissions", prompt])
+        return selected, shlex.join(cmd)
+
+    if selected == CLIENT_CODEX:
+        codex_bin = _resolve_codex_cli()
+        if not codex_bin:
+            raise TerminalClientUnavailableError(
+                "Codex launcher not found in PATH. Install `codex` first or reconfigure NEXO."
+            )
+        target_cwd = str(Path(cwd).expanduser()) if cwd else str(Path.home())
+        cmd = [codex_bin]
+        bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
+        if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
+            cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
+        if profile["model"]:
+            cmd.extend(["-m", profile["model"]])
+        if profile["reasoning_effort"]:
+            cmd.extend(["-c", f'model_reasoning_effort="{profile["reasoning_effort"]}"'])
+        cmd.extend(["-C", target_cwd, prompt])
+        return selected, shlex.join(cmd)
+
+    raise TerminalClientUnavailableError(f"Unsupported terminal client: {selected}")
+
+
 def _resolve_runtime_model_and_effort(
     client: str,
     *,
@@ -270,7 +338,7 @@ def run_automation_prompt(
                 str(output_path),
             ]
             bootstrap_prompt = _load_client_bootstrap_prompt(CLIENT_CODEX)
-            if bootstrap_prompt:
+            if bootstrap_prompt and not _codex_managed_initial_messages_enabled():
                 cmd.extend(["-c", _codex_initial_messages_config(bootstrap_prompt)])
             if resolved_model:
                 cmd.extend(["-m", resolved_model])

package/src/bootstrap_docs.py

@@ -236,6 +236,7 @@ def sync_client_bootstrap(
             "action": "created",
             "path": str(target_path),
             "version": template_version,
+            "content": rendered,
         }
 
     existing = target_path.read_text()
@@ -275,6 +276,7 @@ def sync_client_bootstrap(
         "action": action,
         "path": str(target_path),
         "version": template_version,
+        "content": updated,
     }
 
 

package/src/client_sync.py

@@ -8,6 +8,7 @@ import os
 import shutil
 import subprocess
 import sys
+import tomllib
 from pathlib import Path
 
 from bootstrap_docs import sync_client_bootstrap
@@ -19,6 +20,7 @@ try:
         normalize_backend_key,
         normalize_client_key,
         normalize_client_preferences,
+        resolve_client_runtime_profile,
     )
 except Exception:
     BACKEND_NONE = "none"
@@ -51,6 +53,13 @@ except Exception:
             "automation_backend": "claude_code",
         }
 
+    def resolve_client_runtime_profile(client: str, preferences: dict | None = None) -> dict:
+        defaults = {
+            "claude_code": {"model": "opus", "reasoning_effort": ""},
+            "codex": {"model": "gpt-5.4", "reasoning_effort": "xhigh"},
+        }
+        return dict(defaults.get(client, {}))
+
 
 
 def _user_home() -> Path:
@@ -156,6 +165,118 @@ def _codex_config_path(home: Path | None = None) -> Path:
     return base / ".codex" / "config.toml"
 
 
+def _toml_key(key: str) -> str:
+    if key.replace("_", "").replace("-", "").isalnum():
+        return key
+    escaped = key.replace("\\", "\\\\").replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def _toml_scalar(value) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return json.dumps(value)
+    escaped = str(value).replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+    return f'"{escaped}"'
+
+
+def _toml_inline_table(payload: dict) -> str:
+    parts = [f"{_toml_key(str(key))} = {_toml_value(value)}" for key, value in payload.items()]
+    return "{ " + ", ".join(parts) + " }"
+
+
+def _toml_value(value) -> str:
+    if isinstance(value, dict):
+        return _toml_inline_table(value)
+    if isinstance(value, list):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    return _toml_scalar(value)
+
+
+def _emit_toml_table(table: dict, prefix: tuple[str, ...] = ()) -> list[str]:
+    scalar_lines: list[str] = []
+    child_tables: list[tuple[str, dict]] = []
+    for key, value in table.items():
+        if isinstance(value, dict):
+            child_tables.append((str(key), value))
+        else:
+            scalar_lines.append(f"{_toml_key(str(key))} = {_toml_value(value)}")
+
+    lines: list[str] = []
+    emit_header = bool(prefix and (scalar_lines or not child_tables))
+    if emit_header:
+        lines.append("[" + ".".join(_toml_key(part) for part in prefix) + "]")
+    lines.extend(scalar_lines)
+
+    for child_key, child_value in child_tables:
+        child_lines = _emit_toml_table(child_value, prefix + (child_key,))
+        if child_lines:
+            if lines:
+                lines.append("")
+            lines.extend(child_lines)
+    return lines
+
+
+def _load_toml_object(path: Path) -> dict:
+    if not path.is_file():
+        return {}
+    try:
+        data = tomllib.loads(path.read_text())
+    except Exception as exc:
+        raise ValueError(f"Invalid TOML in {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"Expected TOML table in {path}")
+    return data
+
+
+def _write_toml_object(path: Path, payload: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = _emit_toml_table(payload)
+    path.write_text("\n".join(lines).rstrip() + "\n")
+
+
+def _sync_codex_managed_config(
+    path: Path,
+    *,
+    bootstrap_prompt: str,
+    runtime_profile: dict | None,
+) -> dict:
+    payload = _load_toml_object(path)
+    action = "updated" if payload else "created"
+    runtime_profile = dict(runtime_profile or {})
+
+    if runtime_profile.get("model"):
+        payload["model"] = runtime_profile["model"]
+    if "reasoning_effort" in runtime_profile:
+        payload["model_reasoning_effort"] = runtime_profile.get("reasoning_effort") or ""
+
+    payload["initial_messages"] = [
+        {
+            "role": "system",
+            "content": bootstrap_prompt,
+        }
+    ] if bootstrap_prompt else []
+
+    nexo_table = payload.setdefault("nexo", {})
+    codex_table = nexo_table.setdefault("codex", {})
+    codex_table["bootstrap_managed"] = True
+    codex_table["bootstrap_bytes"] = len(bootstrap_prompt.encode("utf-8")) if bootstrap_prompt else 0
+    if runtime_profile.get("model"):
+        codex_table["managed_model"] = runtime_profile["model"]
+    codex_table["managed_reasoning_effort"] = runtime_profile.get("reasoning_effort", "") or ""
+
+    _write_toml_object(path, payload)
+    return {
+        "ok": True,
+        "action": action,
+        "path": str(path),
+        "bootstrap_managed": True,
+        "model": runtime_profile.get("model", ""),
+        "reasoning_effort": runtime_profile.get("reasoning_effort", "") or "",
+    }
+
+
 def _load_json_object(path: Path) -> dict:
     if not path.is_file():
         return {}
@@ -197,6 +318,7 @@ def sync_claude_code(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
     server_config = build_server_config(
         nexo_home=nexo_home,
@@ -229,6 +351,7 @@ def sync_claude_desktop(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
     server_config = build_server_config(
         nexo_home=nexo_home,
@@ -250,9 +373,12 @@ def sync_codex(
     python_path: str = "",
     operator_name: str = "",
     user_home: str | os.PathLike[str] | None = None,
+    preferences: dict | None = None,
 ) -> dict:
     nexo_home_path = Path(nexo_home).expanduser() if nexo_home else _default_nexo_home()
     home_path = Path(user_home).expanduser() if user_home else _user_home()
+    active_preferences = normalize_client_preferences(preferences)
+    runtime_profile = resolve_client_runtime_profile("codex", preferences=active_preferences)
     server_config = build_server_config(
         nexo_home=nexo_home_path,
         runtime_root=runtime_root,
@@ -276,6 +402,13 @@ def sync_codex(
             user_home=user_home,
         )
         result["bootstrap"] = bootstrap_result
+        if bootstrap_result.get("ok"):
+            prompt_text = bootstrap_result.get("content") or ""
+            result["config"] = _sync_codex_managed_config(
+                config_path,
+                bootstrap_prompt=prompt_text,
+                runtime_profile=runtime_profile,
+            )
         return result
 
     cmd = [codex_bin, "mcp", "add", "nexo"]
@@ -324,6 +457,12 @@ def sync_codex(
     if not bootstrap_result.get("ok"):
         sync_result["ok"] = False
         sync_result["error"] = bootstrap_result.get("error", "Codex bootstrap sync failed")
+        return sync_result
+    sync_result["config"] = _sync_codex_managed_config(
+        config_path,
+        bootstrap_prompt=bootstrap_result.get("content") or "",
+        runtime_profile=runtime_profile,
+    )
     return sync_result
 
 
@@ -372,6 +511,7 @@ def sync_all_clients(
                 python_path=python_path,
                 operator_name=operator_name,
                 user_home=user_home,
+                preferences=preferences,
             )
         except Exception as exc:
             return {"ok": False, "client": label, "error": str(exc)}

package/src/cognitive/__init__.py

@@ -10,14 +10,18 @@ constants are re-exported here for full backwards compatibility:
 # Core: DB, embedding, cosine, constants, tables, redaction
 from cognitive._core import (
     COGNITIVE_DB, EMBEDDING_DIM, LAMBDA_STM, LAMBDA_LTM,
+    DEFAULT_MEMORY_STABILITY, DEFAULT_MEMORY_DIFFICULTY,
     PE_GATE_REJECT, PE_GATE_REFINE, _gate_stats,
     DISCRIMINATING_ENTITIES,
     POSITIVE_SIGNALS, NEGATIVE_SIGNALS, URGENCY_SIGNALS,
     _get_db, _init_tables, _migrate_lifecycle, _migrate_co_activation,
+    _migrate_memory_personalization,
     _auto_migrate_embeddings,
     _get_model, _get_reranker, rerank_results,
     embed, cosine_similarity, _array_to_blob, _blob_to_array,
     extract_temporal_date, redact_secrets,
+    clamp_memory_stability, clamp_memory_difficulty,
+    initial_memory_profile, personalize_decay_rate, rehearsal_profile_update,
 )
 
 # Search

package/src/cognitive/_core.py

@@ -19,6 +19,8 @@ COGNITIVE_DB = os.path.join(_data_dir, "cognitive.db")
 EMBEDDING_DIM = 768
 LAMBDA_STM = 0.004126   # half-life = ln(2) / (7 * 24) ≈ 7 days
 LAMBDA_LTM = 0.000481  # half-life = ln(2) / (60 * 24) ≈ 60 days
+DEFAULT_MEMORY_STABILITY = 1.0
+DEFAULT_MEMORY_DIFFICULTY = 0.5
 
 # Prediction Error Gate thresholds
 PE_GATE_REJECT = 0.85     # similarity > this → reject (not novel enough)
@@ -145,6 +147,7 @@ def _get_db() -> sqlite3.Connection:
         _init_tables(_conn)
         _migrate_lifecycle(_conn)
         _migrate_co_activation(_conn)
+        _migrate_memory_personalization(_conn)
         _auto_migrate_embeddings(_conn)
     return _conn
 
@@ -192,6 +195,79 @@ def _migrate_co_activation(conn: sqlite3.Connection):
     conn.commit()
 
 
+def clamp_memory_stability(value: float | int | str | None) -> float:
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        numeric = DEFAULT_MEMORY_STABILITY
+    return max(0.6, min(3.0, numeric))
+
+
+def clamp_memory_difficulty(value: float | int | str | None) -> float:
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        numeric = DEFAULT_MEMORY_DIFFICULTY
+    return max(0.2, min(1.2, numeric))
+
+
+def initial_memory_profile(source_type: str, *, store: str = "stm") -> tuple[float, float]:
+    source = str(source_type or "").strip().lower()
+    if source in {"learning", "decision", "feedback"}:
+        return 1.2 if store == "stm" else 1.4, 0.4
+    if source in {"dream_insight", "session_summary"}:
+        return 1.1 if store == "stm" else 1.25, 0.55
+    if source in {"sensory", "dialog"}:
+        return 0.9, 0.6
+    return DEFAULT_MEMORY_STABILITY, DEFAULT_MEMORY_DIFFICULTY
+
+
+def personalize_decay_rate(base_lambda: float, *, stability: float, difficulty: float) -> float:
+    stability_factor = clamp_memory_stability(stability)
+    difficulty_factor = 0.75 + (clamp_memory_difficulty(difficulty) * 0.5)
+    return base_lambda * difficulty_factor / stability_factor
+
+
+def rehearsal_profile_update(
+    stability: float,
+    difficulty: float,
+    score: float,
+    *,
+    refinement: bool = False,
+) -> tuple[float, float]:
+    stable = clamp_memory_stability(stability)
+    hard = clamp_memory_difficulty(difficulty)
+    score = max(0.0, min(1.0, float(score or 0.0)))
+
+    stability_gain = 0.03 + max(0.0, score - 0.45) * 0.12
+    if refinement:
+        stability_gain += 0.03
+    new_stability = clamp_memory_stability(stable + stability_gain)
+
+    target_difficulty = clamp_memory_difficulty(1.0 - (score * 0.8))
+    if refinement:
+        target_difficulty = clamp_memory_difficulty(target_difficulty + 0.05)
+    new_difficulty = clamp_memory_difficulty((hard * 0.82) + (target_difficulty * 0.18))
+    return new_stability, new_difficulty
+
+
+def _migrate_memory_personalization(conn: sqlite3.Connection):
+    """Add per-memory stability and difficulty columns if they don't exist."""
+    for table in ("stm_memories", "ltm_memories"):
+        for col, col_type in [
+            ("stability", f"REAL DEFAULT {DEFAULT_MEMORY_STABILITY}"),
+            ("difficulty", f"REAL DEFAULT {DEFAULT_MEMORY_DIFFICULTY}"),
+        ]:
+            try:
+                conn.execute(f"ALTER TABLE {table} ADD COLUMN {col} {col_type}")
+                conn.commit()
+            except sqlite3.OperationalError as e:
+                if "duplicate column" in str(e).lower():
+                    pass
+                else:
+                    raise
+
+
 def _auto_migrate_embeddings(conn: sqlite3.Connection):
     """Auto-detect old 384-dim embeddings and re-embed to 768-dim. Transparent to user."""
     try:
@@ -242,6 +318,8 @@ def _init_tables(conn: sqlite3.Connection):
             last_accessed TEXT DEFAULT (datetime('now')),
             access_count INTEGER DEFAULT 0,
             strength REAL DEFAULT 1.0,
+            stability REAL DEFAULT 1.0,
+            difficulty REAL DEFAULT 0.5,
             promoted_to_ltm INTEGER DEFAULT 0
         );
 
@@ -257,6 +335,8 @@ def _init_tables(conn: sqlite3.Connection):
             last_accessed TEXT DEFAULT (datetime('now')),
             access_count INTEGER DEFAULT 0,
             strength REAL DEFAULT 1.0,
+            stability REAL DEFAULT 1.0,
+            difficulty REAL DEFAULT 0.5,
             is_dormant INTEGER DEFAULT 0,
             original_stm_id INTEGER,
             tags TEXT DEFAULT ''

package/src/cognitive/_decay.py

@@ -2,7 +2,11 @@
 import math
 import numpy as np
 from datetime import datetime, timedelta
-from cognitive._core import _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob, LAMBDA_STM, LAMBDA_LTM, EMBEDDING_DIM
+from cognitive._core import (
+    _get_db, embed, cosine_similarity, _blob_to_array, _array_to_blob,
+    LAMBDA_STM, LAMBDA_LTM, EMBEDDING_DIM,
+    initial_memory_profile, personalize_decay_rate,
+)
 
 
 def _hnsw_invalidate():
@@ -48,20 +52,32 @@ def apply_decay(adaptive: bool = True):
                 _protected_ltm.add(row["id"])
 
     # STM decay (skip pinned)
-    rows = db.execute("SELECT id, last_accessed, strength FROM stm_memories WHERE promoted_to_ltm = 0 AND (lifecycle_state IS NULL OR lifecycle_state != 'pinned')").fetchall()
+    rows = db.execute("SELECT id, last_accessed, strength, stability, difficulty FROM stm_memories WHERE promoted_to_ltm = 0 AND (lifecycle_state IS NULL OR lifecycle_state != 'pinned')").fetchall()
     for row in rows:
         last = datetime.fromisoformat(row["last_accessed"])
         hours = (now - last).total_seconds() / 3600.0
-        decay_rate = LAMBDA_STM * 0.25 if (adaptive and row["id"] in _protected_stm) else LAMBDA_STM
+        decay_rate = personalize_decay_rate(
+            LAMBDA_STM,
+            stability=row["stability"],
+            difficulty=row["difficulty"],
+        )
+        if adaptive and row["id"] in _protected_stm:
+            decay_rate *= 0.25
         new_strength = row["strength"] * math.exp(-decay_rate * hours)
         db.execute("UPDATE stm_memories SET strength = ? WHERE id = ?", (new_strength, row["id"]))
 
     # LTM decay (skip pinned)
-    rows = db.execute("SELECT id, last_accessed, strength FROM ltm_memories WHERE is_dormant = 0 AND (lifecycle_state IS NULL OR lifecycle_state != 'pinned')").fetchall()
+    rows = db.execute("SELECT id, last_accessed, strength, stability, difficulty FROM ltm_memories WHERE is_dormant = 0 AND (lifecycle_state IS NULL OR lifecycle_state != 'pinned')").fetchall()
     for row in rows:
         last = datetime.fromisoformat(row["last_accessed"])
         hours = (now - last).total_seconds() / 3600.0
-        decay_rate = LAMBDA_LTM * 0.25 if (adaptive and row["id"] in _protected_ltm) else LAMBDA_LTM
+        decay_rate = personalize_decay_rate(
+            LAMBDA_LTM,
+            stability=row["stability"],
+            difficulty=row["difficulty"],
+        )
+        if adaptive and row["id"] in _protected_ltm:
+            decay_rate *= 0.25
         new_strength = row["strength"] * math.exp(-decay_rate * hours)
         if new_strength < 0.1:
             db.execute("UPDATE ltm_memories SET strength = ?, is_dormant = 1 WHERE id = ?", (new_strength, row["id"]))
@@ -101,10 +117,10 @@ def promote_stm_to_ltm():
     for row in rows:
         redacted = row["redaction_applied"] if "redaction_applied" in row.keys() else 0
         db.execute(
-            """INSERT INTO ltm_memories (content, embedding, source_type, source_id, source_title, domain, original_stm_id, redaction_applied)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            """INSERT INTO ltm_memories (content, embedding, source_type, source_id, source_title, domain, original_stm_id, redaction_applied, stability, difficulty)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
             (row["content"], row["embedding"], row["source_type"], row["source_id"],
-             row["source_title"], row["domain"], row["id"], redacted)
+             row["source_title"], row["domain"], row["id"], redacted, row["stability"], row["difficulty"])
         )
         db.execute("UPDATE stm_memories SET promoted_to_ltm = 1 WHERE id = ?", (row["id"],))
         promoted += 1
@@ -322,12 +338,13 @@ def dream_cycle(max_insights: int = 50) -> dict:
 
         # Store as LTM with dream_insight tag
         cur = db.execute(
-            """INSERT INTO ltm_memories (content, embedding, source_type, source_id, source_title, domain, tags, strength)
-               VALUES (?, ?, 'dream_insight', ?, ?, ?, 'dream_insight', 0.5)""",
+            """INSERT INTO ltm_memories (content, embedding, source_type, source_id, source_title, domain, tags, strength, stability, difficulty)
+               VALUES (?, ?, 'dream_insight', ?, ?, ?, 'dream_insight', 0.5, ?, ?)""",
             (insight_content, blob,
              f"{mem_a['store']}:{mem_a['id']},{mem_b['store']}:{mem_b['id']}",
              f"Dream: {title_a[:30]} <-> {title_b[:30]}",
-             domain_str)
+             domain_str,
+             *initial_memory_profile("dream_insight", store="ltm"))
         )
         insight_id = cur.lastrowid