nexo-brain 2.6.21 → 2.7.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "2.6.21",
+  "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,18 +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, `2.6.20` makes the recommended Claude profile explicit across installer, runtime defaults, existing installs, and the update path itself with `Opus 4.6 with 1M context`, and `2.6.21` upgrades Deep Sleep from passive nightly analysis toward concrete engineering action.
-
-- 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.
-- Deep Sleep now semantically deduplicates followups, consolidates overlapping learnings, flags contradictory learnings for review, and backfills explicit engineering followups when recurring patterns imply a concrete fix.
-- 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
 
@@ -523,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
@@ -636,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.
 
@@ -665,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
 
@@ -842,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
 
@@ -956,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.21",
+  "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();

package/src/doctor/providers/runtime.py

@@ -6,6 +6,7 @@ import json
 import os
 import platform
 import plistlib
+import re
 import subprocess
 import sys
 import time
@@ -38,6 +39,8 @@ SPECIAL_LAUNCHAGENT_IDS = {"prevent-sleep", "tcc-approve"}
 SPECIAL_ENV_NORMALIZE_IDS = SPECIAL_LAUNCHAGENT_IDS
 OPTIONALS_FILE = NEXO_HOME / "config" / "optionals.json"
 SCHEDULE_FILE = NEXO_HOME / "config" / "schedule.json"
+PACKAGE_JSON = NEXO_CODE / "package.json"
+CHANGELOG_FILE = NEXO_CODE / "CHANGELOG.md"
 
 
 def _codex_bootstrap_config_status() -> dict:
@@ -190,6 +193,7 @@ def _client_assumption_regressions() -> list[str]:
         return []
     allowed_claude_projects = {
         (src_root / "scripts" / "deep-sleep" / "collect.py").resolve(),
+        Path(__file__).resolve(),
     }
     offenders: list[str] = []
     for path in src_root.rglob("*.py"):
@@ -224,6 +228,44 @@ def _load_json(path: Path) -> dict:
     return json.loads(path.read_text())
 
 
+def _latest_periodic_summary(kind: str) -> dict | None:
+    pattern = f"*-{kind}-summary.json"
+    candidates: list[tuple[str, Path]] = []
+    for path in (NEXO_HOME / "operations" / "deep-sleep").glob(pattern):
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        label = str(payload.get("label", "") or "")
+        if label:
+            candidates.append((label, path))
+    if not candidates:
+        return None
+    _, path = sorted(candidates, key=lambda item: item[0])[-1]
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _package_version() -> str:
+    try:
+        payload = json.loads(PACKAGE_JSON.read_text())
+    except Exception:
+        return ""
+    return str(payload.get("version", "") or "").strip()
+
+
+def _top_changelog_version() -> str:
+    try:
+        text = CHANGELOG_FILE.read_text(encoding="utf-8")
+    except Exception:
+        return ""
+    match = re.search(r"^## \[([^\]]+)\]", text, flags=re.MULTILINE)
+    return match.group(1).strip() if match else ""
+
+
 def _count_checks(checks) -> int:
     if isinstance(checks, list):
         return len(checks)
@@ -1529,6 +1571,143 @@ def check_client_assumption_regressions() -> DoctorCheck:
     )
 
 
+def check_protocol_compliance() -> DoctorCheck:
+    summary = _latest_periodic_summary("weekly")
+    if not summary:
+        return DoctorCheck(
+            id="runtime.protocol_compliance",
+            tier="runtime",
+            status="degraded",
+            severity="warn",
+            summary="No weekly Deep Sleep protocol summary found",
+            repair_plan=[
+                "Run the Deep Sleep pipeline so weekly summaries include protocol compliance again",
+            ],
+            escalation_prompt=(
+                "NEXO cannot verify heartbeat / guard_check / change_log compliance because the latest weekly Deep Sleep summary is missing."
+            ),
+        )
+
+    protocol = summary.get("protocol_summary") or {}
+    overall = protocol.get("overall_compliance_pct")
+    guard = protocol.get("guard_check") or {}
+    heartbeat = protocol.get("heartbeat") or {}
+    change_log = protocol.get("change_log") or {}
+    evidence = [f"weekly summary: {summary.get('label', 'unknown')}"]
+    if overall is not None:
+        evidence.append(f"overall protocol compliance: {overall:.1f}%")
+    if guard.get("compliance_pct") is not None:
+        evidence.append(
+            f"guard_check: {guard.get('executed', 0)}/{guard.get('required', 0)} ({guard['compliance_pct']:.1f}%)"
+        )
+    if heartbeat.get("compliance_pct") is not None:
+        evidence.append(
+            f"heartbeat with context: {heartbeat.get('with_context', 0)}/{heartbeat.get('total', 0)} ({heartbeat['compliance_pct']:.1f}%)"
+        )
+    if change_log.get("compliance_pct") is not None:
+        evidence.append(
+            f"change_log after edits: {change_log.get('logged', 0)}/{change_log.get('edits', 0)} ({change_log['compliance_pct']:.1f}%)"
+        )
+
+    status = "healthy"
+    severity = "info"
+    repair_plan: list[str] = []
+    if overall is None:
+        status = "degraded"
+        severity = "warn"
+        repair_plan.append("Ensure Deep Sleep extractions keep writing protocol_summary data")
+    elif overall < 45:
+        status = "critical"
+        severity = "error"
+    elif overall < 70:
+        status = "degraded"
+        severity = "warn"
+
+    if status != "healthy":
+        repair_plan.extend(
+            [
+                "Reinforce heartbeat discipline on every user message",
+                "Call nexo_guard_check before production/shared edits",
+                "Record production changes with nexo_change_log after editing",
+            ]
+        )
+
+    return DoctorCheck(
+        id="runtime.protocol_compliance",
+        tier="runtime",
+        status=status,
+        severity=severity,
+        summary="Protocol compliance looks healthy" if status == "healthy" else "Protocol compliance needs hardening",
+        evidence=evidence,
+        repair_plan=repair_plan,
+        escalation_prompt=(
+            "Heartbeat / guard_check / change_log discipline is drifting. NEXO is at risk of repeating known errors and hiding change history."
+        ) if status != "healthy" else "",
+    )
+
+
+def check_release_artifact_sync() -> DoctorCheck:
+    version = _package_version()
+    changelog_version = _top_changelog_version()
+    evidence = []
+    status = "healthy"
+    severity = "info"
+    repair_plan: list[str] = []
+
+    if version:
+        evidence.append(f"package version: {version}")
+    if changelog_version:
+        evidence.append(f"top changelog version: {changelog_version}")
+
+    if version and changelog_version and version != changelog_version:
+        status = "critical"
+        severity = "error"
+        evidence.append("package/changelog release version mismatch")
+        repair_plan.append("Bump or align CHANGELOG.md before publishing")
+
+    sync_script = NEXO_CODE / "scripts" / "sync_release_artifacts.py"
+    if not sync_script.is_file():
+        status = "critical"
+        severity = "error"
+        evidence.append(f"missing release artifact sync script at {sync_script}")
+        repair_plan.append("Restore scripts/sync_release_artifacts.py")
+    else:
+        try:
+            result = subprocess.run(
+                [sys.executable, str(sync_script), "--check"],
+                cwd=str(NEXO_CODE),
+                capture_output=True,
+                text=True,
+            )
+        except Exception as exc:
+            status = "degraded" if status == "healthy" else status
+            severity = "warn" if severity == "info" else severity
+            evidence.append(f"artifact sync check failed to run: {exc}")
+            repair_plan.append("Run scripts/sync_release_artifacts.py manually and inspect the local environment")
+        else:
+            if result.returncode != 0:
+                status = "degraded" if status == "healthy" else status
+                severity = "warn" if severity == "info" else severity
+                detail = result.stderr.strip() or result.stdout.strip() or "artifact sync check failed"
+                evidence.append(detail.splitlines()[0])
+                repair_plan.append("Run scripts/sync_release_artifacts.py before publishing")
+            else:
+                evidence.append("release artifacts in sync")
+
+    return DoctorCheck(
+        id="runtime.release_artifacts",
+        tier="runtime",
+        status=status,
+        severity=severity,
+        summary="Release artifact discipline OK" if status == "healthy" else "Release artifact discipline needs attention",
+        evidence=evidence,
+        repair_plan=repair_plan,
+        escalation_prompt=(
+            "Release-facing artifacts drifted away from the source version contract. Publishing now risks another hotfix release."
+        ) if status != "healthy" else "",
+    )
+
+
 def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
     return [
@@ -1542,6 +1721,8 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         check_claude_desktop_shared_brain(),
         check_transcript_source_parity(),
         check_client_assumption_regressions(),
+        check_protocol_compliance(),
+        check_release_artifact_sync(),
         check_launchagent_integrity(fix=fix),
         check_personal_script_registry(fix=fix),
         check_skill_health(fix=fix),

package/src/scripts/deep-sleep/apply_findings.py

@@ -992,6 +992,201 @@ def _load_period_syntheses(target_date: str, *, window_days: int) -> list[dict]:
     return syntheses
 
 
+def _load_period_extractions(target_date: str, *, window_days: int) -> list[dict]:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    payloads: list[dict] = []
+    for offset in range(window_days):
+        date_str = (target_day - timedelta(days=offset)).strftime("%Y-%m-%d")
+        path = DEEP_SLEEP_DIR / f"{date_str}-extractions.json"
+        if not path.is_file():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            payloads.append(payload)
+    payloads.reverse()
+    return payloads
+
+
+def _load_period_applied_logs(target_date: str, *, window_days: int) -> list[dict]:
+    target_day = datetime.strptime(target_date, "%Y-%m-%d")
+    payloads: list[dict] = []
+    for offset in range(window_days):
+        date_str = (target_day - timedelta(days=offset)).strftime("%Y-%m-%d")
+        path = DEEP_SLEEP_DIR / f"{date_str}-applied.json"
+        if not path.is_file():
+            continue
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        if isinstance(payload, dict):
+            payloads.append(payload)
+    payloads.reverse()
+    return payloads
+
+
+def _safe_pct(numerator: float, denominator: float) -> float | None:
+    if denominator <= 0:
+        return None
+    return round((numerator / denominator) * 100.0, 1)
+
+
+def _aggregate_protocol_summary(extractions: list[dict]) -> dict:
+    totals = {
+        "sessions": 0,
+        "guard_check": {"required": 0, "executed": 0},
+        "heartbeat": {"total": 0, "with_context": 0},
+        "change_log": {"edits": 0, "logged": 0},
+    }
+
+    for payload in extractions:
+        for item in payload.get("extractions", []) or []:
+            if not isinstance(item, dict) or item.get("error"):
+                continue
+            totals["sessions"] += 1
+            protocol_summary = item.get("protocol_summary") or {}
+            for key in ("guard_check", "heartbeat", "change_log"):
+                current = protocol_summary.get(key) or {}
+                if key == "guard_check":
+                    totals[key]["required"] += int(current.get("required", 0) or 0)
+                    totals[key]["executed"] += int(current.get("executed", 0) or 0)
+                elif key == "heartbeat":
+                    totals[key]["total"] += int(current.get("total", 0) or 0)
+                    totals[key]["with_context"] += int(current.get("with_context", 0) or 0)
+                else:
+                    totals[key]["edits"] += int(current.get("edits", 0) or 0)
+                    totals[key]["logged"] += int(current.get("logged", 0) or 0)
+
+    guard_pct = _safe_pct(totals["guard_check"]["executed"], totals["guard_check"]["required"])
+    heartbeat_pct = _safe_pct(totals["heartbeat"]["with_context"], totals["heartbeat"]["total"])
+    change_pct = _safe_pct(totals["change_log"]["logged"], totals["change_log"]["edits"])
+    available = [value for value in (guard_pct, heartbeat_pct, change_pct) if value is not None]
+
+    totals["guard_check"]["compliance_pct"] = guard_pct
+    totals["heartbeat"]["compliance_pct"] = heartbeat_pct
+    totals["change_log"]["compliance_pct"] = change_pct
+    totals["overall_compliance_pct"] = round(sum(available) / len(available), 1) if available else None
+    return totals
+
+
+def _aggregate_delivery_metrics(applied_logs: list[dict]) -> dict:
+    totals = {
+        "runs": len(applied_logs),
+        "applied_actions": 0,
+        "deferred_actions": 0,
+        "skipped_dedupe": 0,
+        "errors": 0,
+        "engineering_followups": 0,
+    }
+    for payload in applied_logs:
+        stats = payload.get("stats") or {}
+        totals["applied_actions"] += int(stats.get("applied", 0) or 0)
+        totals["deferred_actions"] += int(stats.get("deferred", 0) or 0)
+        totals["skipped_dedupe"] += int(stats.get("skipped_dedupe", 0) or 0)
+        totals["errors"] += int(stats.get("errors", 0) or 0)
+        for action in payload.get("applied_actions", []) or []:
+            details = action.get("details") or {}
+            if action.get("action_type") == "followup_create":
+                description = str(details.get("description", "") or "") + " " + str(details.get("reasoning", "") or "")
+                if "engineering" in description.lower() or "guardrail" in description.lower():
+                    totals["engineering_followups"] += 1
+
+    attempted = totals["applied_actions"] + totals["deferred_actions"] + totals["skipped_dedupe"] + totals["errors"]
+    totals["dedupe_rate_pct"] = _safe_pct(totals["skipped_dedupe"], attempted)
+    totals["error_rate_pct"] = _safe_pct(totals["errors"], attempted)
+    return totals
+
+
+def _load_previous_period_summary(kind: str, label: str) -> dict | None:
+    pattern = f"*-{kind}-summary.json"
+    candidates: list[tuple[str, Path]] = []
+    for path in DEEP_SLEEP_DIR.glob(pattern):
+        try:
+            payload = json.loads(path.read_text())
+        except Exception:
+            continue
+        candidate_label = str(payload.get("label", "") or "")
+        if candidate_label and candidate_label < label:
+            candidates.append((candidate_label, path))
+    if not candidates:
+        return None
+    _, path = sorted(candidates, key=lambda item: item[0])[-1]
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _build_project_pulse(top_projects: list[dict], previous_summary: dict | None) -> list[dict]:
+    previous_scores: dict[str, float] = {}
+    if previous_summary:
+        for item in previous_summary.get("project_pulse", []) or previous_summary.get("top_projects", []) or []:
+            project = str(item.get("project", "") or "")
+            if project:
+                previous_scores[project] = float(item.get("score", 0) or 0)
+
+    pulse: list[dict] = []
+    for item in top_projects:
+        project = str(item.get("project", "") or "")
+        score = float(item.get("score", 0) or 0)
+        previous_score = previous_scores.get(project, 0.0)
+        delta = round(score - previous_score, 2)
+        if score >= 18:
+            status = "critical"
+        elif score >= 10:
+            status = "elevated"
+        else:
+            status = "watch"
+        if delta >= 2.0:
+            trend = "rising"
+        elif delta <= -2.0:
+            trend = "cooling"
+        else:
+            trend = "steady"
+        pulse.append(
+            {
+                "project": project,
+                "score": round(score, 2),
+                "delta_vs_previous": delta,
+                "trend": trend,
+                "status": status,
+                "signals": item.get("signals", {}),
+                "reasons": item.get("reasons", []),
+            }
+        )
+    return pulse
+
+
+def _build_period_trend(summary: dict, previous_summary: dict | None) -> dict:
+    if not previous_summary:
+        return {
+            "has_previous": False,
+            "avg_mood_delta": None,
+            "avg_trust_delta": None,
+            "total_corrections_delta": None,
+            "protocol_compliance_delta": None,
+        }
+
+    current_protocol = summary.get("protocol_summary", {}).get("overall_compliance_pct")
+    previous_protocol = (previous_summary.get("protocol_summary") or {}).get("overall_compliance_pct")
+    current_mood = summary.get("avg_mood_score")
+    previous_mood = previous_summary.get("avg_mood_score")
+    current_trust = summary.get("avg_trust_score")
+    previous_trust = previous_summary.get("avg_trust_score")
+
+    return {
+        "has_previous": True,
+        "avg_mood_delta": round(current_mood - previous_mood, 3) if isinstance(current_mood, (int, float)) and isinstance(previous_mood, (int, float)) else None,
+        "avg_trust_delta": round(current_trust - previous_trust, 1) if isinstance(current_trust, (int, float)) and isinstance(previous_trust, (int, float)) else None,
+        "total_corrections_delta": int(summary.get("total_corrections", 0) or 0) - int(previous_summary.get("total_corrections", 0) or 0),
+        "protocol_compliance_delta": round(current_protocol - previous_protocol, 1) if isinstance(current_protocol, (int, float)) and isinstance(previous_protocol, (int, float)) else None,
+    }
+
+
 def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, window_days: int) -> dict:
     target_day = datetime.strptime(target_date, "%Y-%m-%d")
     window_start = (target_day - timedelta(days=max(0, window_days - 1))).strftime("%Y-%m-%d")
@@ -1001,6 +1196,8 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         else target_day.strftime("%Y-%m")
     )
     syntheses = _load_period_syntheses(target_date, window_days=window_days)
+    extractions = _load_period_extractions(target_date, window_days=window_days)
+    applied_logs = _load_period_applied_logs(target_date, window_days=window_days)
     if not any(item.get("date") == target_date for item in syntheses):
         syntheses.append(synthesis)
 
@@ -1037,6 +1234,10 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         {"title": title, "count": count}
         for title, count in agenda_counter.most_common(6)
     ]
+    protocol_summary = _aggregate_protocol_summary(extractions)
+    delivery_metrics = _aggregate_delivery_metrics(applied_logs)
+    previous_summary = _load_previous_period_summary(kind, label)
+    project_pulse = _build_project_pulse(top_projects, previous_summary)
 
     summary_parts = [f"{len(syntheses)} Deep Sleep run(s)"]
     if top_projects:
@@ -1045,9 +1246,11 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         summary_parts.append(f"recurring pattern: {top_patterns[0]['pattern']}")
     if avg_trust is not None:
         summary_parts.append(f"avg trust {avg_trust:.1f}")
+    if protocol_summary.get("overall_compliance_pct") is not None:
+        summary_parts.append(f"protocol {protocol_summary['overall_compliance_pct']:.1f}%")
     summary = " | ".join(summary_parts)
 
-    return {
+    period_summary = {
         "kind": kind,
         "label": label,
         "window_days": window_days,
@@ -1059,11 +1262,15 @@ def _build_period_summary(target_date: str, synthesis: dict, *, kind: str, windo
         "avg_trust_score": avg_trust,
         "total_corrections": total_corrections,
         "top_projects": top_projects,
+        "project_pulse": project_pulse,
         "top_patterns": top_patterns,
         "recurring_agenda": recurring_agenda,
+        "protocol_summary": protocol_summary,
+        "delivery_metrics": delivery_metrics,
         "summary": summary,
     }
-
+    period_summary["trend"] = _build_period_trend(period_summary, previous_summary)
+    return period_summary
 
 def _render_period_summary_markdown(summary: dict) -> str:
     lines = [
@@ -1082,6 +1289,47 @@ def _render_period_summary_markdown(summary: dict) -> str:
         lines.append(f"> {summary['summary']}")
         lines.append("")
 
+    protocol_summary = summary.get("protocol_summary") or {}
+    if protocol_summary:
+        lines.append("## Protocol Compliance")
+        lines.append("")
+        overall = protocol_summary.get("overall_compliance_pct")
+        if overall is not None:
+            lines.append(f"- Overall compliance: {overall:.1f}%")
+        guard = protocol_summary.get("guard_check", {})
+        heartbeat = protocol_summary.get("heartbeat", {})
+        change_log = protocol_summary.get("change_log", {})
+        if guard:
+            lines.append(
+                f"- guard_check: {guard.get('executed', 0)}/{guard.get('required', 0)}"
+                + (f" ({guard['compliance_pct']:.1f}%)" if guard.get("compliance_pct") is not None else "")
+            )
+        if heartbeat:
+            lines.append(
+                f"- heartbeat with context: {heartbeat.get('with_context', 0)}/{heartbeat.get('total', 0)}"
+                + (f" ({heartbeat['compliance_pct']:.1f}%)" if heartbeat.get("compliance_pct") is not None else "")
+            )
+        if change_log:
+            lines.append(
+                f"- change_log after edits: {change_log.get('logged', 0)}/{change_log.get('edits', 0)}"
+                + (f" ({change_log['compliance_pct']:.1f}%)" if change_log.get("compliance_pct") is not None else "")
+            )
+        lines.append("")
+
+    delivery_metrics = summary.get("delivery_metrics") or {}
+    if delivery_metrics:
+        lines.append("## Loop Output")
+        lines.append("")
+        lines.append(f"- Applied actions: {delivery_metrics.get('applied_actions', 0)}")
+        lines.append(f"- Deferred actions: {delivery_metrics.get('deferred_actions', 0)}")
+        lines.append(f"- Dedupe skips: {delivery_metrics.get('skipped_dedupe', 0)}")
+        lines.append(f"- Engineering followups: {delivery_metrics.get('engineering_followups', 0)}")
+        if delivery_metrics.get("dedupe_rate_pct") is not None:
+            lines.append(f"- Dedupe rate: {delivery_metrics['dedupe_rate_pct']:.1f}%")
+        if delivery_metrics.get("error_rate_pct") is not None:
+            lines.append(f"- Error rate: {delivery_metrics['error_rate_pct']:.1f}%")
+        lines.append("")
+
     if summary.get("top_projects"):
         lines.append("## Top Projects")
         lines.append("")
@@ -1091,6 +1339,20 @@ def _render_period_summary_markdown(summary: dict) -> str:
                 lines.append(f"  Reasons: {', '.join(item['reasons'])}")
         lines.append("")
 
+    if summary.get("project_pulse"):
+        lines.append("## Project Pulse")
+        lines.append("")
+        for item in summary["project_pulse"][:5]:
+            delta = item.get("delta_vs_previous")
+            delta_label = ""
+            if isinstance(delta, (int, float)):
+                delta_label = f" | Δ {delta:+.2f}"
+            lines.append(
+                f"- **{item['project']}** — {item.get('status', 'watch')} / {item.get('trend', 'steady')}"
+                f" | score {item.get('score', 0)}{delta_label}"
+            )
+        lines.append("")
+
     if summary.get("top_patterns"):
         lines.append("## Recurring Patterns")
         lines.append("")
@@ -1105,6 +1367,20 @@ def _render_period_summary_markdown(summary: dict) -> str:
             lines.append(f"- {item['title']} ({item['count']}x)")
         lines.append("")
 
+    trend = summary.get("trend") or {}
+    if trend.get("has_previous"):
+        lines.append("## Trend vs Previous")
+        lines.append("")
+        if trend.get("avg_mood_delta") is not None:
+            lines.append(f"- Mood delta: {trend['avg_mood_delta']:+.3f}")
+        if trend.get("avg_trust_delta") is not None:
+            lines.append(f"- Trust delta: {trend['avg_trust_delta']:+.1f}")
+        if trend.get("total_corrections_delta") is not None:
+            lines.append(f"- Corrections delta: {trend['total_corrections_delta']:+d}")
+        if trend.get("protocol_compliance_delta") is not None:
+            lines.append(f"- Protocol delta: {trend['protocol_compliance_delta']:+.1f}%")
+        lines.append("")
+
     return "\n".join(lines).rstrip() + "\n"