nexo-brain 2.6.20 → 2.7.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.20",
+  "version": "2.7.0",
   "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,17 +38,15 @@ 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, `2.6.15` hardens the installed-runtime migration path so existing users actually receive the managed bootstrap updates cleanly, `2.6.16` pushes the system further in three directions, `2.6.17` finishes the annoying last-mile migration bugs for real existing installs, `2.6.18` tightens the remaining practical gaps around manual Codex use, Deep Sleep horizon artifacts, and retrieval honesty, and `2.6.20` makes the recommended Claude profile explicit across installer, runtime defaults, existing installs, and the update path itself: `Opus 4.6 with 1M context`.
-
-- 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.
-- Codex config now also persists a managed `mcp_servers.nexo` entry, so the shared brain survives even if ad-hoc Codex MCP state drifts.
-- Runtime doctor now audits recent Codex sessions for real startup discipline and verifies Claude Desktop shared-brain metadata explicitly instead of treating both as invisible best-effort wiring.
-- Retrieval is smarter by default: HyDE and spreading activation now auto-enable when the query shape benefits, while exact lookups remain conservative.
-- Retrieval explanations now surface confidence and the auto-strategy that fired, while associative expansion trims itself back to `top_k` instead of leaking low-signal neighbors.
-- 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.
-- Deep Sleep now also carries project-priority weighting into its long-horizon context and writes reusable weekly/monthly summary artifacts instead of reasoning only day by day.
-- Existing installs that already had NEXO connected to Codex now backfill that client state automatically during update/sync, so the managed Codex bootstrap actually lands without manual cleanup.
-- Bootstrap docs now fall back to the operator name `NEXO` when local metadata is blank, avoiding broken headings in `CLAUDE.md` and `AGENTS.md`.
+Versions `2.6.14` through `2.6.21` established the practical shared-brain baseline: managed Claude/Codex bootstrap, Codex config sync, transcript-aware Deep Sleep, 60-day long-horizon analysis, weekly/monthly summary artifacts, retrieval auto-mode, and the first Deep Sleep engineering loop.
+
+Version `2.7.0` closes the next operational gap:
+
+- Weekly/monthly Deep Sleep summaries now include protocol compliance, engineering-loop output, project pulse, and trend-vs-previous-period data.
+- Runtime doctor now audits both weekly protocol compliance and release-artifact sync drift instead of leaving those checks implicit.
+- The repo now ships `scripts/verify_release_readiness.py`, and tagged publish runs it automatically so release discipline is enforced in the product itself.
+- The dashboard now surfaces `What Matters Now`, `What Is Drifting`, and `What Is Improving` directly from the periodic Deep Sleep summaries.
+- The unreleased Codex launcher fixes after `v2.6.21` are now included: stronger `nexo chat` client selection, corrected launch mode handling, tracked last terminal choice, and aligned interactive flags.
 
 ### Client Capability Matrix
 
@@ -522,7 +520,7 @@ npx nexo-brain  # detects current version, migrates automatically
 
 NEXO Brain includes a local CLI that runs independently of any single terminal client:
 
-- `nexo chat` — launch the configured terminal client with NEXO as the operator
+- `nexo chat` — launch a NEXO terminal client; if both Claude Code and Codex are available, it asks every time which one to open and puts the last-used client first
 - `nexo update` — sync runtime from source, run migrations, reconcile schedules
 - `nexo doctor --tier runtime` — boot/runtime/deep diagnostics with `--fix` mode
 - `nexo scripts list` — list all personal scripts and their status
@@ -635,20 +633,20 @@ The installer handles everything and syncs the same `nexo` MCP brain into Claude
 After install, use the runtime CLI:
 
 ```bash
-nexo chat          # Launch the configured terminal client (Claude Code or Codex)
+nexo chat          # Launch a NEXO terminal client (asks if both Claude Code and Codex are available)
 nexo doctor        # Check runtime health
 nexo update        # Pull latest version and sync
 nexo clients sync  # Re-sync Claude Code/Desktop/Codex to the same brain
 nexo scripts list  # See your personal scripts
 ```
 
-During install, NEXO now asks which interactive clients you want to connect, which one `nexo chat` should open by default, whether to enable background automation, which backend should run that automation, and which model profile each active terminal/backend should use. Shared brain stays on in every mode.
+During install, NEXO now asks which interactive clients you want to connect, which one `nexo chat` should suggest first when multiple terminal clients are available, whether to enable background automation, which backend should run that automation, and which model profile each active terminal/backend should use. Shared brain stays on in every mode.
 
 Recommended defaults:
 - Claude Code: `Opus 4.6 with 1M context`
 - Codex: `gpt-5.4` with `xhigh` reasoning
 
-Or use the shell alias created during install (e.g. `atlas`), which now runs `nexo chat .` so it opens whichever terminal client you selected as default.
+Or use the shell alias created during install (e.g. `atlas`), which now runs `nexo chat .` so it opens the terminal client you pick for that session, with the last-used option shown first.
 
 Your operator will greet you immediately — adapted to the time of day, resuming from where you left off. No cold starts.
 
@@ -664,6 +662,7 @@ The project still recommends Claude Code as the primary path, but contributions
 
 Maintainers and contributors touching startup, bootstrap, Deep Sleep, or shared-brain behavior should also use the client parity checklist:
 - [docs/client-parity-checklist.md](docs/client-parity-checklist.md)
+- `python3 scripts/verify_release_readiness.py`
 
 ### What Gets Installed
 
@@ -841,7 +840,7 @@ When Claude Desktop is installed, `nexo-brain`, `nexo update`, and `nexo clients
 
 ### Codex
 
-When Codex CLI is available, `nexo-brain`, `nexo update`, and `nexo clients sync` register the same `nexo` MCP server via `codex mcp add`, so Codex uses the same local memory store as Claude Code and Claude Desktop. If selected during install, `nexo chat` can open Codex directly and background automation can also run through Codex. The current recommended Codex profile is `gpt-5.4` with `xhigh` reasoning.
+When Codex CLI is available, `nexo-brain`, `nexo update`, and `nexo clients sync` register the same `nexo` MCP server via `codex mcp add`, so Codex uses the same local memory store as Claude Code and Claude Desktop. If selected during install, `nexo chat` can open Codex directly and background automation can also run through Codex. Interactive `nexo chat` launches use Codex's aggressive no-confirmation mode so the session does not stall on repetitive approval prompts. The current recommended Codex profile is `gpt-5.4` with `xhigh` reasoning.
 
 ### OpenClaw
 
@@ -955,7 +954,7 @@ If NEXO Brain is useful to you, consider:
 - **Personal scripts registry**: Scripts in `NEXO_HOME/scripts/` tracked in SQLite with metadata, categories, schedules. Full lifecycle: create, sync, reconcile, schedule, unschedule, remove.
 - **Orchestrator removed from core** (breaking): Was opt-in personal automation adding complexity for all users. Existing users keep their setup in `NEXO_HOME/scripts/`.
 - **Claude Code plugin structure**: `plugin.json`, entry point, packaging for marketplace submission.
-- **`nexo chat`**: Official command to launch the configured terminal client with NEXO as operator.
+- **`nexo chat`**: Official command to launch a NEXO terminal client, asking when multiple supported terminal clients are available.
 - **Managed Evolution hardening**: Can modify core behavior modules with rollback followups.
 - Cron recovery hardened: TCC diagnostics, keepalive sync, personal schedule catchup.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.20",
+  "version": "2.7.0",
   "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

@@ -109,6 +109,10 @@ def _codex_initial_messages_config(prompt_text: str) -> str:
     return f'initial_messages=[{{role="system",content={json.dumps(prompt_text, ensure_ascii=False)}}}]'
 
 
+def _codex_interactive_launch_flags() -> list[str]:
+    return ["--sandbox", "danger-full-access", "--ask-for-approval", "never"]
+
+
 def build_interactive_client_command(
     *,
     target: str | os.PathLike[str],
@@ -140,7 +144,7 @@ def build_interactive_client_command(
             raise TerminalClientUnavailableError(
                 "Codex launcher not found in PATH. Install `codex` first or reconfigure NEXO."
             )
-        cmd = [codex_bin]
+        cmd = [codex_bin, *_codex_interactive_launch_flags()]
         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)])
@@ -201,7 +205,7 @@ def build_followup_terminal_shell_command(
                 "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]
+        cmd = [codex_bin, *_codex_interactive_launch_flags()]
         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)])

package/src/cli.py

@@ -41,6 +41,11 @@ from pathlib import Path
 
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
+TERMINAL_CLIENT_LABELS = {
+    "claude_code": "Claude Code",
+    "codex": "Codex",
+}
+TERMINAL_CLIENT_ORDER = ("claude_code", "codex")
 
 
 def _get_version() -> str:
@@ -844,8 +849,73 @@ def _dashboard(args):
     return _service_control("dashboard", args.action)
 
 
+def _terminal_client_label(client: str) -> str:
+    return TERMINAL_CLIENT_LABELS.get(client, client.replace("_", " ").title())
+
+
+def _ordered_available_terminal_clients(preferences: dict, detected: dict) -> list[str]:
+    enabled = preferences.get("interactive_clients", {})
+    last_used = str(preferences.get("last_terminal_client", "")).strip()
+    preferred = str(preferences.get("default_terminal_client", "")).strip()
+    ordered: list[str] = []
+
+    for client in (last_used, preferred, *TERMINAL_CLIENT_ORDER):
+        if client in TERMINAL_CLIENT_ORDER and client not in ordered:
+            ordered.append(client)
+
+    return [
+        client
+        for client in ordered
+        if enabled.get(client, False) and detected.get(client, {}).get("installed", False)
+    ]
+
+
+def _preferred_terminal_client_label(preferences: dict, clients: list[str]) -> str:
+    last_used = str(preferences.get("last_terminal_client", "")).strip()
+    if clients and clients[0] == last_used:
+        return "last choice"
+    return "default"
+
+
+def _prompt_for_terminal_client(
+    clients: list[str],
+    normalize_client_key,
+    *,
+    preferred_label: str = "default",
+) -> str | None:
+    if not clients:
+        return None
+    if len(clients) == 1:
+        return clients[0]
+
+    while True:
+        print("Select terminal client for this chat:")
+        for index, client in enumerate(clients, start=1):
+            suffix = f" [{preferred_label}]" if index == 1 else ""
+            print(f"  {index}. {_terminal_client_label(client)}{suffix}")
+
+        try:
+            response = input(f"Choose 1-{len(clients)} [1]: ").strip()
+        except EOFError:
+            return clients[0]
+
+        if not response:
+            return clients[0]
+        if response.isdigit():
+            choice = int(response)
+            if 1 <= choice <= len(clients):
+                return clients[choice - 1]
+
+        client_key = normalize_client_key(response)
+        if client_key in clients:
+            return client_key
+
+        print("Invalid choice. Try again.", file=sys.stderr)
+
+
 def _chat(args):
     target = args.path or "."
+    selected_client = getattr(args, "client", None)
 
     try:
         from auto_update import startup_preflight
@@ -867,20 +937,44 @@ def _chat(args):
         pass
 
     try:
+        from client_preferences import (
+            detect_installed_clients,
+            load_client_preferences,
+            normalize_client_key,
+            save_client_preferences,
+        )
         from agent_runner import TerminalClientUnavailableError, launch_interactive_client
     except ImportError:
         print("Agent runner module not found. Ensure NEXO is properly installed.", file=sys.stderr)
         return 1
 
+    if not selected_client:
+        try:
+            preferences = load_client_preferences()
+            detected = detect_installed_clients()
+            clients = _ordered_available_terminal_clients(preferences, detected)
+            selected_client = _prompt_for_terminal_client(
+                clients,
+                normalize_client_key,
+                preferred_label=_preferred_terminal_client_label(preferences, clients),
+            )
+        except Exception:
+            selected_client = None
+
     try:
         result = launch_interactive_client(
             target=target,
-            client=getattr(args, "client", None),
+            client=selected_client,
             env=os.environ.copy(),
         )
     except TerminalClientUnavailableError as exc:
         print(str(exc), file=sys.stderr)
         return 1
+    if result.returncode == 0 and selected_client:
+        try:
+            save_client_preferences(last_terminal_client=normalize_client_key(selected_client))
+        except Exception:
+            pass
     return int(result.returncode)
 
 
@@ -1014,7 +1108,7 @@ def _print_help():
     print(f"""NEXO Runtime CLI v{v}
 
 Commands:
-  nexo chat [path] [--client claude_code|codex]      Launch the selected terminal client
+  nexo chat [path] [--client claude_code|codex]      Launch a NEXO terminal client
   nexo doctor [--tier boot|runtime|deep|all] [--fix]   System diagnostics
   nexo scripts list|create|classify|sync|reconcile|ensure-schedules|schedules|run|doctor|call|unschedule|remove
                                                       Personal scripts
@@ -1036,12 +1130,12 @@ def main():
     sub = parser.add_subparsers(dest="command")
 
     # -- chat --
-    chat_parser = sub.add_parser("chat", help="Launch the selected terminal client")
+    chat_parser = sub.add_parser("chat", help="Launch a NEXO terminal client")
     chat_parser.add_argument("path", nargs="?", default=".", help="Working directory (default: current directory)")
     chat_parser.add_argument(
         "--client",
         choices=["claude_code", "codex"],
-        help="Override the configured default terminal client",
+        help="Override the chat picker and launch a specific terminal client",
     )
 
     # -- scripts --

package/src/client_preferences.py

@@ -73,6 +73,7 @@ def default_client_preferences() -> dict:
             CLIENT_CLAUDE_DESKTOP: False,
         },
         "default_terminal_client": CLIENT_CLAUDE_CODE,
+        "last_terminal_client": "",
         "automation_enabled": True,
         "automation_backend": CLIENT_CLAUDE_CODE,
         "client_runtime_profiles": default_client_runtime_profiles(),
@@ -189,6 +190,14 @@ def normalize_default_terminal_client(value, interactive_clients: dict[str, bool
     return CLIENT_CLAUDE_CODE
 
 
+def normalize_last_terminal_client(value, interactive_clients: dict[str, bool] | None = None) -> str:
+    interactive_clients = normalize_interactive_clients(interactive_clients or {})
+    candidate = normalize_client_key(value)
+    if candidate in TERMINAL_CLIENT_KEYS and interactive_clients.get(candidate, False):
+        return candidate
+    return ""
+
+
 def normalize_automation_enabled(value) -> bool:
     return _coerce_bool(value, True)
 
@@ -282,6 +291,10 @@ def normalize_client_preferences(
         schedule.get("default_terminal_client"),
         interactive_clients=interactive_clients,
     )
+    last_terminal_client = normalize_last_terminal_client(
+        schedule.get("last_terminal_client"),
+        interactive_clients=interactive_clients,
+    )
     automation_backend = normalize_automation_backend(
         schedule.get("automation_backend"),
         automation_enabled=automation_enabled,
@@ -295,6 +308,7 @@ def normalize_client_preferences(
     return {
         "interactive_clients": interactive_clients,
         "default_terminal_client": default_terminal_client,
+        "last_terminal_client": last_terminal_client,
         "automation_enabled": automation_enabled,
         "automation_backend": automation_backend,
         "client_runtime_profiles": runtime_profiles,
@@ -307,6 +321,7 @@ def apply_client_preferences(
     *,
     interactive_clients: dict | None = None,
     default_terminal_client: str | None = None,
+    last_terminal_client: str | None = None,
     automation_enabled=None,
     automation_backend: str | None = None,
     client_runtime_profiles: dict | None = None,
@@ -324,6 +339,10 @@ def apply_client_preferences(
         default_terminal_client if default_terminal_client is not None else current["default_terminal_client"],
         interactive_clients=merged["interactive_clients"],
     )
+    merged["last_terminal_client"] = normalize_last_terminal_client(
+        last_terminal_client if last_terminal_client is not None else current.get("last_terminal_client", ""),
+        interactive_clients=merged["interactive_clients"],
+    )
     merged["automation_backend"] = normalize_automation_backend(
         automation_backend if automation_backend is not None else current["automation_backend"],
         automation_enabled=merged["automation_enabled"],
@@ -349,6 +368,7 @@ def save_client_preferences(
     *,
     interactive_clients: dict | None = None,
     default_terminal_client: str | None = None,
+    last_terminal_client: str | None = None,
     automation_enabled=None,
     automation_backend: str | None = None,
     client_runtime_profiles: dict | None = None,
@@ -358,6 +378,7 @@ def save_client_preferences(
         load_schedule_config(),
         interactive_clients=interactive_clients,
         default_terminal_client=default_terminal_client,
+        last_terminal_client=last_terminal_client,
         automation_enabled=automation_enabled,
         automation_backend=automation_backend,
         client_runtime_profiles=client_runtime_profiles,

package/src/dashboard/app.py

@@ -156,6 +156,106 @@ def _email_db():
     return conn
 
 
+def _deep_sleep_dir() -> Path:
+    nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    return nexo_home / "operations" / "deep-sleep"
+
+
+def _latest_periodic_summary(kind: str) -> dict:
+    root = _deep_sleep_dir()
+    pattern = f"*-{kind}-summary.json"
+    candidates = []
+    for path in root.glob(pattern):
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        label = str(payload.get("label", "") or "")
+        if label:
+            candidates.append((label, payload))
+    if not candidates:
+        return {}
+    return sorted(candidates, key=lambda item: item[0])[-1][1]
+
+
+def _summarize_engineering_loop(weekly: dict, monthly: dict) -> dict:
+    matters_now = []
+    for item in (weekly.get("project_pulse") or weekly.get("top_projects") or [])[:4]:
+        matters_now.append(
+            {
+                "title": str(item.get("project", "") or "unknown"),
+                "detail": f"score {item.get('score', 0)}",
+                "tone": str(item.get("status", "watch") or "watch"),
+                "meta": ", ".join(item.get("reasons", [])[:2]) if isinstance(item.get("reasons"), list) else "",
+            }
+        )
+
+    drifting = []
+    protocol = weekly.get("protocol_summary") or {}
+    for key, label in (
+        ("guard_check", "guard_check"),
+        ("heartbeat", "heartbeat"),
+        ("change_log", "change_log"),
+    ):
+        item = protocol.get(key) or {}
+        pct = item.get("compliance_pct")
+        if isinstance(pct, (int, float)) and pct < 70:
+            drifting.append(
+                {
+                    "title": label,
+                    "detail": f"{pct:.1f}% compliance",
+                    "tone": "critical" if pct < 45 else "elevated",
+                    "meta": "",
+                }
+            )
+    for item in (weekly.get("top_patterns") or [])[:3]:
+        pattern = str(item.get("pattern", "") or "")
+        if pattern:
+            drifting.append(
+                {
+                    "title": pattern,
+                    "detail": f"{item.get('count', 0)}x this period",
+                    "tone": "watch",
+                    "meta": "recurring pattern",
+                }
+            )
+        if len(drifting) >= 4:
+            break
+
+    improving = []
+    trend = weekly.get("trend") or {}
+    trust_delta = trend.get("avg_trust_delta")
+    if isinstance(trust_delta, (int, float)) and trust_delta > 0:
+        improving.append({"title": "Trust", "detail": f"{trust_delta:+.1f}", "tone": "healthy", "meta": "vs previous window"})
+    delivery = weekly.get("delivery_metrics") or {}
+    if int(delivery.get("engineering_followups", 0) or 0) > 0:
+        improving.append(
+            {
+                "title": "Engineering followups",
+                "detail": str(delivery.get("engineering_followups", 0)),
+                "tone": "healthy",
+                "meta": "guardrails created from recurring patterns",
+            }
+        )
+    protocol_delta = trend.get("protocol_compliance_delta")
+    if isinstance(protocol_delta, (int, float)) and protocol_delta > 0:
+        improving.append({"title": "Protocol", "detail": f"{protocol_delta:+.1f}%", "tone": "healthy", "meta": "vs previous window"})
+    corrections_delta = trend.get("total_corrections_delta")
+    if isinstance(corrections_delta, int) and corrections_delta < 0:
+        improving.append({"title": "Corrections", "detail": f"{corrections_delta:+d}", "tone": "healthy", "meta": "lower is better"})
+    mood_delta = trend.get("avg_mood_delta")
+    if isinstance(mood_delta, (int, float)) and mood_delta > 0:
+        improving.append({"title": "Mood", "detail": f"{mood_delta:+.3f}", "tone": "healthy", "meta": "vs previous window"})
+
+    return {
+        "weekly": weekly,
+        "monthly": monthly,
+        "matters_now": matters_now[:4],
+        "drifting": drifting[:4],
+        "improving": improving[:4],
+    }
+
+
 # ---------------------------------------------------------------------------
 # HTML page routes — Jinja2 with fallback to plain file
 # ---------------------------------------------------------------------------
@@ -396,6 +496,30 @@ async def api_trust():
     }
 
 
+@app.get("/api/project-pulse")
+async def api_project_pulse(kind: str = Query("weekly", pattern="^(weekly|monthly)$")):
+    """Latest project pressure snapshot from Deep Sleep summaries."""
+    summary = _latest_periodic_summary(kind)
+    if not summary:
+        return JSONResponse({"error": f"No {kind} summary found"}, status_code=404)
+    return {
+        "kind": kind,
+        "label": summary.get("label"),
+        "project_pulse": summary.get("project_pulse", []),
+        "top_projects": summary.get("top_projects", []),
+    }
+
+
+@app.get("/api/engineering-loop")
+async def api_engineering_loop():
+    """Dashboard narrative: what matters now, what is drifting, what is improving."""
+    weekly = _latest_periodic_summary("weekly")
+    monthly = _latest_periodic_summary("monthly")
+    if not weekly and not monthly:
+        return JSONResponse({"error": "No periodic Deep Sleep summaries found"}, status_code=404)
+    return _summarize_engineering_loop(weekly or {}, monthly or {})
+
+
 @app.get("/api/adaptive")
 async def api_adaptive():
     """Adaptive personality: current weight state + mode history."""

package/src/dashboard/templates/dashboard.html

@@ -138,6 +138,30 @@
       </div>
     </div>
   </div>
+
+  <!-- Row 3: engineering loop narrative -->
+  <div class="grid grid-cols-3 gap-4">
+    <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
+      <div class="text-xs uppercase tracking-wider text-slate-400 font-medium mb-3">What Matters Now</div>
+      <ul id="matters-now-list" class="space-y-2">
+        <li class="text-xs text-slate-600 py-1">loading...</li>
+      </ul>
+    </div>
+
+    <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
+      <div class="text-xs uppercase tracking-wider text-slate-400 font-medium mb-3">What Is Drifting</div>
+      <ul id="drifting-list" class="space-y-2">
+        <li class="text-xs text-slate-600 py-1">loading...</li>
+      </ul>
+    </div>
+
+    <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
+      <div class="text-xs uppercase tracking-wider text-slate-400 font-medium mb-3">What Is Improving</div>
+      <ul id="improving-list" class="space-y-2">
+        <li class="text-xs text-slate-600 py-1">loading...</li>
+      </ul>
+    </div>
+  </div>
 </div>
 
 <!-- Quick Create Modal -->
@@ -244,7 +268,7 @@ async function submitQuickCreate(e) {
 async function loadDashboardData() {
   const today = getToday();
 
-  const [trustData, statsData, remindersData, followupsData, sessionsData, watchdogData, inboxData] =
+  const [trustData, statsData, remindersData, followupsData, sessionsData, watchdogData, inboxData, engineeringData] =
     await Promise.all([
       fetchJSON('/api/trust'),
       fetchJSON('/api/stats'),
@@ -253,6 +277,7 @@ async function loadDashboardData() {
       fetchJSON('/api/sessions?limit=3'),
       fetchJSON('/api/watchdog'),
       fetchJSON('/api/inbox/unread'),
+      fetchJSON('/api/engineering-loop'),
     ]);
 
   // --- Trust Score (animated gauge) ---
@@ -426,6 +451,39 @@ async function loadDashboardData() {
       badge.classList.add('flex');
     }
   }
+
+  // --- Engineering loop narrative ---
+  const toneClass = tone => {
+    if (tone === 'critical') return 'text-red-400';
+    if (tone === 'elevated' || tone === 'watch') return 'text-amber-400';
+    return 'text-emerald-400';
+  };
+  const renderNarrativeList = (id, items, emptyText) => {
+    const node = document.getElementById(id);
+    if (!node) return;
+    if (!items || items.length === 0) {
+      node.innerHTML = `<li class="text-xs text-slate-600 py-1">${escapeHtml(emptyText)}</li>`;
+      return;
+    }
+    node.innerHTML = items.map(item => `
+      <li class="border-b border-slate-800/30 pb-2 last:border-0 last:pb-0">
+        <div class="flex items-center justify-between gap-2">
+          <span class="text-xs text-slate-300">${escapeHtml(item.title || '--')}</span>
+          <span class="text-[10px] font-mono ${toneClass(item.tone)}">${escapeHtml(item.detail || '')}</span>
+        </div>
+        ${item.meta ? `<div class="text-[10px] text-slate-600 mt-1">${escapeHtml(item.meta)}</div>` : ''}
+      </li>
+    `).join('');
+  };
+  if (engineeringData && !engineeringData.error) {
+    renderNarrativeList('matters-now-list', engineeringData.matters_now, 'No active pressure detected');
+    renderNarrativeList('drifting-list', engineeringData.drifting, 'No major drift detected');
+    renderNarrativeList('improving-list', engineeringData.improving, 'No improvement deltas yet');
+  } else {
+    renderNarrativeList('matters-now-list', [], 'No periodic summary available');
+    renderNarrativeList('drifting-list', [], 'No periodic summary available');
+    renderNarrativeList('improving-list', [], 'No periodic summary available');
+  }
 }
 
 loadDashboardData();