nexo-brain 6.0.0 → 6.0.1

package/.claude-plugin/plugin.json

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

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `6.0.0` is the current packaged-runtime line: **BREAKING** tier-only setup. Onboarding asks for one resonance tier (`maximo`/`alto`/`medio`/`bajo`) and that choice drives every backend via `src/resonance_tiers.json`; the per-backend model/effort prompts are gone and the legacy `client_runtime_profiles.{claude_code,codex}.{model,reasoning_effort}` are silently purged from `schedule.json` on upgrade. Protocol strictness is no longer configurable — interactive TTY sessions run `strict`, non-TTY (crons, pipes, tests) run `lenient`; `NEXO_PROTOCOL_STRICTNESS` env, `preferences.protocol_strictness`, and the `default/normal/off/warn/soft` aliases are all removed. `preferences.show_pending_at_start` moves to NEXO Desktop's electron-store. The seven core hooks are now unified behind `src/hooks/manifest.json` (plugin and npm modes read the same file), two new hooks ship (`Notification` for live-session activity and `SubagentStop` for auto-closing stale `protocol_tasks`), and `auto_capture.py` is wired to both `UserPromptSubmit` and `PostToolUse` with a persistent 1h dedup table plus an automatic `nexo_learning_add` on correction matches. `~/.nexo/hooks_status.json` is published after every `registerAllCoreHooks()` so NEXO Desktop ≥0.12.0 can render Hooks activos X/Y. New `nexo-brain --skip` flag aliases `--yes`/`--defaults`. Full suite 1057 passed, 1 skipped.
+Version `6.0.1` is the current packaged-runtime line: hotfix on top of the 6.0.0 release. `protocol_settings.py` now treats the process as interactive when **either** stdin+stdout are TTYs **or** `NEXO_INTERACTIVE=1` is exported — closes the gap where NEXO Desktop 0.12.0 spawned `claude` through pipes and Brain fell back to `lenient` even with a human in the loop. The `PostToolUse` hook also gains an inbox autodetect stage: when the session has unread `nexo_send` messages and has gone 60s+ without a heartbeat, it emits a `systemMessage` asking the agent to run `nexo_heartbeat` and consume them. Rate-limited to one reminder per minute per SID (new `hook_inbox_reminders` table, migration m42). Added `sessions.last_heartbeat_ts`, stamped by every successful heartbeat. `NEXO_INTERACTIVE` is an internal Brain↔Electron contract — not user-facing, not a resurrection of the removed `NEXO_PROTOCOL_STRICTNESS`.
+
+Previously in `6.0.0`: **BREAKING** tier-only setup. Onboarding asks for one resonance tier (`maximo`/`alto`/`medio`/`bajo`) and that choice drives every backend via `src/resonance_tiers.json`; the per-backend model/effort prompts are gone and the legacy `client_runtime_profiles.{claude_code,codex}.{model,reasoning_effort}` are silently purged from `schedule.json` on upgrade. Protocol strictness is no longer configurable — interactive TTY sessions run `strict`, non-TTY (crons, pipes, tests) run `lenient`; `NEXO_PROTOCOL_STRICTNESS` env, `preferences.protocol_strictness`, and the `default/normal/off/warn/soft` aliases are all removed. `preferences.show_pending_at_start` moves to NEXO Desktop's electron-store. The seven core hooks are now unified behind `src/hooks/manifest.json` (plugin and npm modes read the same file), two new hooks ship (`Notification` for live-session activity and `SubagentStop` for auto-closing stale `protocol_tasks`), and `auto_capture.py` is wired to both `UserPromptSubmit` and `PostToolUse` with a persistent 1h dedup table plus an automatic `nexo_learning_add` on correction matches. `~/.nexo/hooks_status.json` is published after every `registerAllCoreHooks()` so NEXO Desktop ≥0.12.0 can render Hooks activos X/Y. New `nexo-brain --skip` flag aliases `--yes`/`--defaults`. Full suite 1057 passed, 1 skipped.
 
 Previously in `5.10.2`: auto-bootstraps `brain/profile.json` from `brain/calibration.json` on `nexo update` when the profile file is missing, empty, or corrupt AND calibration carries at least one of `meta.role`, `meta.technical_level`, `name`, `language`. NEXO Desktop's *Preferencias → Avanzado* tab used to render an empty `{}` for that block when the onboarding flow had been interrupted; now it either shows the seeded profile or a friendly explanation of what each file is for, paired with Desktop `v0.11.2` which adds header descriptions to both JSON blocks. Never overwrites a populated profile, never raises, idempotent. Also fixes a latent host-filesystem leak in `test_user_facing_caller_with_no_user_default_uses_alto` exposed by the v5.10.1 migration.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain \u2014 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/db/__init__.py

@@ -81,6 +81,14 @@ from db._sessions import (
     track_files, untrack_files, get_all_tracked_files,
     send_message, get_inbox,
     ask_question, answer_question, get_pending_questions, check_answer,
+    update_last_heartbeat_ts, get_last_heartbeat_ts,
+    count_pending_inbox_messages, resolve_sid_from_external,
+)
+
+# PostToolUse inbox-reminder rate limit (v6.0.1)
+_hook_inbox_reminders = _load_submodule("db._hook_inbox_reminders")
+from db._hook_inbox_reminders import (
+    get_last_reminder_ts, mark_reminder_sent, reset_reminders_for_sid,
 )
 
 # Reminders and followups

package/src/db/_hook_inbox_reminders.py

@@ -0,0 +1,73 @@
+"""NEXO DB — Hook inbox reminder bookkeeping (v6.0.1).
+
+The ``PostToolUse`` hook may surface a ``systemMessage`` that tells the
+agent it has unread ``nexo_send`` messages when the session has been
+autopiloting through tool calls for a while. This module backs the rate
+limit: at most one reminder per minute per SID, stored in the tiny
+``hook_inbox_reminders`` table created by migration m42.
+
+All helpers are best-effort on the read path and raise on unexpected
+write failures — callers (the hook itself) wrap calls in try/except so
+a malformed DB never breaks the tool pipeline.
+"""
+from __future__ import annotations
+
+from db._core import get_db
+
+
+def get_last_reminder_ts(sid: str) -> float | None:
+    """Return the epoch seconds of the last inbox reminder for ``sid``.
+
+    Returns None when no row exists yet. Never raises — treats any
+    unexpected error as "no prior reminder recorded" so the hook can
+    decide to emit a fresh one.
+    """
+    if not sid:
+        return None
+    try:
+        row = get_db().execute(
+            "SELECT last_reminder_ts FROM hook_inbox_reminders WHERE sid = ?",
+            (sid,),
+        ).fetchone()
+    except Exception:
+        return None
+    if row is None:
+        return None
+    try:
+        return float(row[0]) if row[0] is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def mark_reminder_sent(sid: str, ts: float) -> None:
+    """Record that a reminder was surfaced for ``sid`` at ``ts``.
+
+    Uses SQLite UPSERT so the table tracks one row per SID. Silently
+    swallows DB errors; the hook caller logs / skips as needed.
+    """
+    if not sid:
+        return
+    try:
+        conn = get_db()
+        conn.execute(
+            "INSERT INTO hook_inbox_reminders (sid, last_reminder_ts) "
+            "VALUES (?, ?) "
+            "ON CONFLICT(sid) DO UPDATE SET last_reminder_ts = excluded.last_reminder_ts",
+            (sid, float(ts)),
+        )
+        conn.commit()
+    except Exception:
+        pass
+
+
+def reset_reminders_for_sid(sid: str) -> None:
+    """Delete the reminder row for ``sid``. Used by tests that want to
+    start from a clean slate between assertions."""
+    if not sid:
+        return
+    try:
+        conn = get_db()
+        conn.execute("DELETE FROM hook_inbox_reminders WHERE sid = ?", (sid,))
+        conn.commit()
+    except Exception:
+        pass

package/src/db/_schema.py

@@ -1010,6 +1010,37 @@ def _m41_automation_sessions_columns(conn):
     )
 
 
+def _m42_v6_0_1_hotfix(conn):
+    """v6.0.1 hotfix — last_heartbeat_ts on sessions + hook_inbox_reminders.
+
+    Two surfaces:
+
+    1. ``sessions.last_heartbeat_ts`` is a REAL column holding the epoch
+       seconds of the most recent ``nexo_heartbeat`` call for that SID.
+       The PostToolUse hook uses it to decide whether to emit an
+       inbox-reminder systemMessage on autopilot sessions that have not
+       checked their inbox in a while.
+
+    2. ``hook_inbox_reminders`` is a tiny table storing the last time we
+       surfaced an inbox reminder per SID. The hook reads/writes it to
+       enforce a rate limit of at most one reminder per minute per
+       session, so long streams of tool calls do not spam the user.
+
+    Idempotent by construction: ``_migrate_add_column`` is a no-op when
+    the column exists, ``CREATE TABLE IF NOT EXISTS`` likewise.
+    """
+    _migrate_add_column(conn, "sessions", "last_heartbeat_ts", "REAL")
+    _migrate_add_index(
+        conn, "idx_sessions_last_heartbeat_ts", "sessions", "last_heartbeat_ts"
+    )
+    conn.execute(
+        """CREATE TABLE IF NOT EXISTS hook_inbox_reminders (
+            sid TEXT PRIMARY KEY,
+            last_reminder_ts REAL NOT NULL
+        )"""
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -1052,6 +1083,7 @@ MIGRATIONS = [
     (39, "hook_runs", _m39_hook_runs),
     (40, "classification_columns", _m40_classification_columns),
     (41, "automation_sessions_columns", _m41_automation_sessions_columns),
+    (42, "v6_0_1_hotfix", _m42_v6_0_1_hotfix),
 ]
 
 

package/src/db/_sessions.py

@@ -123,6 +123,110 @@ def clean_stale_sessions() -> int:
     return count
 
 
+def update_last_heartbeat_ts(sid: str, ts: float | None = None) -> None:
+    """Stamp ``sessions.last_heartbeat_ts`` with the current heartbeat time.
+
+    Added in v6.0.1 so the PostToolUse hook can decide whether an
+    autopilot session has gone long enough without a heartbeat to
+    deserve an inbox reminder. Called from ``handle_heartbeat`` after
+    every successful heartbeat. Never raises — treats a missing
+    session row (test harnesses, race on cleanup) as a no-op.
+    """
+    if not sid:
+        return
+    try:
+        sid = _validate_sid(sid)
+    except Exception:
+        return
+    stamp = float(ts) if ts is not None else now_epoch()
+    conn = get_db()
+    try:
+        conn.execute(
+            "UPDATE sessions SET last_heartbeat_ts = ? WHERE sid = ?",
+            (stamp, sid),
+        )
+        conn.commit()
+    except Exception:
+        pass
+
+
+def get_last_heartbeat_ts(sid: str) -> float | None:
+    """Return the epoch seconds of the most recent heartbeat for ``sid``.
+
+    Returns None when either the session does not exist or the column
+    has never been populated (pre-v6.0.1 rows, or a brand-new session
+    that has not yet called ``nexo_heartbeat``). The hook treats None
+    as "too new to reason about" and skips the reminder.
+    """
+    if not sid:
+        return None
+    conn = get_db()
+    try:
+        row = conn.execute(
+            "SELECT last_heartbeat_ts FROM sessions WHERE sid = ?", (sid,)
+        ).fetchone()
+    except Exception:
+        return None
+    if not row:
+        return None
+    try:
+        return float(row["last_heartbeat_ts"]) if row["last_heartbeat_ts"] is not None else None
+    except (TypeError, ValueError, KeyError):
+        return None
+
+
+def count_pending_inbox_messages(sid: str) -> int:
+    """Count unread ``messages`` addressed to ``sid`` (direct or broadcast).
+
+    The concrete read-tracking table is ``message_reads``; a message is
+    "pending" when no row in ``message_reads`` matches ``(message_id, sid)``
+    and the message is not self-sent. Added in v6.0.1 for the PostToolUse
+    inbox-autodetect reminder.
+    """
+    if not sid:
+        return 0
+    try:
+        row = get_db().execute(
+            "SELECT COUNT(*) FROM messages m "
+            "WHERE (m.to_sid = 'all' OR m.to_sid = ?) "
+            "AND m.from_sid != ? "
+            "AND m.id NOT IN (SELECT message_id FROM message_reads WHERE sid = ?)",
+            (sid, sid, sid),
+        ).fetchone()
+    except Exception:
+        return 0
+    if not row:
+        return 0
+    try:
+        return int(row[0])
+    except (TypeError, ValueError):
+        return 0
+
+
+def resolve_sid_from_external(external_id: str) -> str:
+    """Map a Claude Code ``session_id`` back to the NEXO SID we track.
+
+    The PostToolUse hook payload carries the external Claude session id;
+    we want the internal SID to query the messages table. Returns an
+    empty string when no session matches or the external id is empty.
+    """
+    external = (external_id or "").strip()
+    if not external:
+        return ""
+    try:
+        conn = get_db()
+        row = conn.execute(
+            "SELECT sid FROM sessions WHERE external_session_id = ? OR claude_session_id = ? "
+            "ORDER BY last_update_epoch DESC LIMIT 1",
+            (external, external),
+        ).fetchone()
+    except Exception:
+        return ""
+    if row and row["sid"]:
+        return str(row["sid"])
+    return ""
+
+
 def search_sessions(keyword: str) -> list[dict]:
     """Find sessions whose task contains keyword (case-insensitive)."""
     conn = get_db()

package/src/hooks/post_tool_use.py

@@ -7,6 +7,12 @@ heartbeat-posttool). Also pipes the tool result through auto_capture.py so
 decision/correction/explicit facts from tool outputs reach the cognitive
 layer.
 
+v6.0.1 adds an inbox-autodetect stage at the end: when the session has
+unread ``nexo_send`` messages AND has gone for ≥60s without a heartbeat,
+the hook emits a ``systemMessage`` telling the agent to run
+``nexo_heartbeat`` and pick them up. Rate-limited to one reminder per
+minute per SID via the ``hook_inbox_reminders`` table (migration m42).
+
 Failures in one sub-step do not cancel the others. Hook is best-effort;
 exit code is always 0 so Claude Code never sees a PostToolUse failure.
 """
@@ -23,6 +29,91 @@ from pathlib import Path
 _DIR = Path(__file__).resolve().parent
 _NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
+INBOX_CHECK_THRESHOLD_SECONDS = int(
+    os.environ.get("NEXO_INBOX_CHECK_THRESHOLD_SECONDS", "60")
+)
+
+
+def _resolve_sid_from_payload(payload: dict) -> str:
+    """Resolve the NEXO SID from the hook payload or fall back to env.
+
+    Claude Code delivers its own ``session_id`` in the payload; we map
+    it back to our SID via ``sessions.external_session_id``. The
+    fallback is ``NEXO_SID`` in the environment, which headless crons
+    export directly.
+    """
+    candidates: list[str] = []
+    if isinstance(payload, dict):
+        for key in ("nexo_sid", "sid", "session_id", "sessionId"):
+            value = payload.get(key)
+            if isinstance(value, str) and value.strip():
+                candidates.append(value.strip())
+    env_sid = os.environ.get("NEXO_SID", "").strip()
+    if env_sid:
+        candidates.append(env_sid)
+    env_claude = os.environ.get("CLAUDE_SESSION_ID", "").strip()
+    if env_claude:
+        candidates.append(env_claude)
+
+    # Try each candidate: first as a NEXO-shaped SID (nexo-<epoch>-<pid>),
+    # then as a Claude external id we need to translate.
+    try:
+        sys.path.insert(0, str(_DIR.parent))
+        from db import (  # type: ignore
+            resolve_sid_from_external,
+            get_last_heartbeat_ts,
+        )
+    except Exception:
+        return ""
+
+    for cand in candidates:
+        if cand.startswith("nexo-"):
+            return cand
+        resolved = resolve_sid_from_external(cand)
+        if resolved:
+            return resolved
+    return ""
+
+
+def check_inbox_and_emit_reminder(sid: str, now: float | None = None) -> str | None:
+    """Return the systemMessage string when a reminder should be surfaced.
+
+    Returns ``None`` when any gate fails (no sid, no pending messages,
+    heartbeat too recent, rate-limited on reminders).
+    """
+    if not sid:
+        return None
+    try:
+        sys.path.insert(0, str(_DIR.parent))
+        from db import (  # type: ignore
+            count_pending_inbox_messages,
+            get_last_heartbeat_ts,
+            get_last_reminder_ts,
+            mark_reminder_sent,
+        )
+    except Exception:
+        return None
+
+    pending = count_pending_inbox_messages(sid)
+    if pending <= 0:
+        return None
+    last_hb = get_last_heartbeat_ts(sid)
+    if last_hb is None:
+        return None  # pre-v6.0.1 row or brand-new session
+    current = float(now) if now is not None else time.time()
+    if current - last_hb < INBOX_CHECK_THRESHOLD_SECONDS:
+        return None
+    last_rem = get_last_reminder_ts(sid) or 0.0
+    if current - last_rem < INBOX_CHECK_THRESHOLD_SECONDS:
+        return None  # rate limit: max 1 reminder/min/session
+    mark_reminder_sent(sid, current)
+    return (
+        f"[NEXO Protocol Enforcer] You have {pending} unread inbox message(s) "
+        f"sent by other NEXO sessions. Run nexo_heartbeat with your SID now "
+        f"to receive them before continuing — other sessions may be blocked "
+        f"waiting on your response."
+    )
+
 
 def _record(duration_ms: int, exit_code: int, summary: str) -> None:
     try:
@@ -116,6 +207,18 @@ def main() -> int:
 
     exits.append(_run_auto_capture(payload))
 
+    # v6.0.1 — inbox autodetect runs LAST so it sees the latest DB state
+    # (including any writes the previous steps may have done). Emits a
+    # single-line JSON systemMessage so Claude Code surfaces it to the
+    # agent without breaking the tool pipeline.
+    try:
+        sid = _resolve_sid_from_payload(payload)
+        reminder = check_inbox_and_emit_reminder(sid)
+        if reminder:
+            print(json.dumps({"systemMessage": reminder}))
+    except Exception:
+        pass
+
     final_exit = max(exits) if exits else 0
     duration_ms = int((time.time() - started) * 1000)
     _record(duration_ms, final_exit, f"steps={len(exits)}")

package/src/protocol_settings.py

@@ -2,62 +2,87 @@ from __future__ import annotations
 
 """Protocol-discipline settings.
 
-v6.0.0 breaking change: there is no user-facing toggle anymore.
-
-- Interactive TTY sessions always run ``strict``.
-- Non-TTY contexts (crons, tests, pipes) always run ``lenient`` — exactly
-  what every scheduled background job needs to avoid noisy protocol nags.
-- ``VALID_PROTOCOL_STRICTNESS`` still exposes ``learning`` for internal
-  use by self-audit and onboarding flows, but it is never the active mode
-  unless the code explicitly asks for it.
-
-The v5.x surfaces this module used to expose — ``NEXO_PROTOCOL_STRICTNESS``
-environment variable, ``preferences.protocol_strictness`` in calibration,
-and the ``default/normal/off/warn/soft`` aliases — are all removed on
-purpose. Users who relied on them see their value silently cleared by the
-v6.0.0 calibration migration and fall through to the TTY/no-TTY decision.
+v6.0.0 removed the user-facing strictness toggle. v6.0.1 layers an
+Electron-class escape hatch on top:
+
+- Interactive contexts run ``strict``. Interactive is defined as either
+  of two signals:
+    * both stdin and stdout are attached to a TTY (terminal users), OR
+    * the client set ``NEXO_INTERACTIVE=1`` in the child process env
+      (Electron clients like NEXO Desktop spawn ``claude`` through
+      pipes, so ``isatty()`` returns False even with a human in the
+      loop).
+- Everything else (crons, tests, piped scripts, headless automation)
+  runs ``lenient``.
+
+``NEXO_INTERACTIVE`` is a contract between Brain and its interactive
+clients. It is NOT user-facing. It is NOT documented to operators. It
+is NOT the removed ``NEXO_PROTOCOL_STRICTNESS`` knob — that one let a
+user force a strictness value, which confused people. This one only
+signals interactivity; the actual strictness still follows the
+TTY/interactive test above.
+
+``VALID_PROTOCOL_STRICTNESS`` still exposes ``learning`` for internal
+use by self-audit and onboarding flows, but nothing in this module
+ever selects it.
 """
 
+import os
 import sys
 
 
 DEFAULT_PROTOCOL_STRICTNESS = "strict"
 VALID_PROTOCOL_STRICTNESS = {"lenient", "strict", "learning"}
 
+# The only accepted value is the exact string "1". Truthy-looking values
+# such as "true", "yes", "on" are deliberately ignored so a typo cannot
+# silently re-enable strict mode on a headless machine.
+_NEXO_INTERACTIVE_OPT_IN = "1"
 
-def _stdio_is_tty() -> bool:
-    """True only when both stdin and stdout are attached to a terminal.
 
-    The double-check matters: a headless cron typically redirects stdout
-    to a log file but leaves stdin as a TTY. Treating that as interactive
-    would re-enable strict mode for every cron invocation, which is
-    exactly the noise v6.0.0 set out to eliminate.
+def _is_interactive() -> bool:
+    """True when the process should be treated as interactive.
+
+    Two signals are accepted (OR semantics):
+      1. stdin and stdout are both TTYs.
+      2. ``NEXO_INTERACTIVE`` is exactly ``"1"`` — the Brain↔Electron
+         contract used by NEXO Desktop ≥0.12.0.
+    Anything else returns False, falling through to ``lenient``.
     """
+    if os.environ.get("NEXO_INTERACTIVE") == _NEXO_INTERACTIVE_OPT_IN:
+        return True
     try:
         return bool(sys.stdin.isatty() and sys.stdout.isatty())
     except Exception:
         return False
 
 
+# Kept as a thin alias for any v6.0.0 caller that imported the old helper
+# directly. New code should prefer ``_is_interactive()``.
+def _stdio_is_tty() -> bool:
+    """Deprecated in v6.0.1. Delegates to ``_is_interactive()`` so the
+    NEXO_INTERACTIVE contract applies regardless of which name the caller
+    imported."""
+    return _is_interactive()
+
+
 def normalize_protocol_strictness(value: str | None) -> str:
     """Coerce an arbitrary input into one of the canonical values.
 
-    Unknown or empty values return the TTY-derived default. The only
-    normalization done is lowercasing and whitespace stripping — the v5.x
-    alias table is gone.
+    Unknown or empty values fall through to the interactivity test. The
+    only normalisation is lowercasing and whitespace stripping — the
+    v5.x alias table (default/normal/off/warn/soft) is gone.
     """
     candidate = str(value or "").strip().lower()
     if candidate in VALID_PROTOCOL_STRICTNESS:
         return candidate
-    return "strict" if _stdio_is_tty() else "lenient"
+    return "strict" if _is_interactive() else "lenient"
 
 
 def get_protocol_strictness() -> str:
     """Return the active strictness for this process.
 
-    No configuration, no environment, no calibration — only the process
-    context decides. Callers that want to force a value for tests can
-    monkeypatch ``sys.stdin.isatty`` / ``sys.stdout.isatty`` or call
-    ``normalize_protocol_strictness`` directly with an explicit value.
+    No configuration, no user-facing environment, no calibration value —
+    only the process context and the Brain↔client contract decide.
     """
-    return "strict" if _stdio_is_tty() else "lenient"
+    return "strict" if _is_interactive() else "lenient"

package/src/tools_sessions.py

@@ -465,8 +465,15 @@ def handle_heartbeat(sid: str, task: str, context_hint: str = '') -> str:
 
 def _handle_heartbeat_inner(sid: str, task: str, context_hint: str = '') -> str:
     """Inner body of handle_heartbeat — wrapped by tool_span above."""
-    from db import get_db
+    from db import get_db, update_last_heartbeat_ts
     update_session(sid, task)
+    # v6.0.1 — stamp last_heartbeat_ts so the PostToolUse hook can
+    # decide whether to surface a pending-inbox reminder on autopilot
+    # sessions. Best-effort: never break the heartbeat on failure.
+    try:
+        update_last_heartbeat_ts(sid)
+    except Exception:
+        pass
 
     # Temporal anchor — surface authoritative UTC time so clients never drift
     # on date/day-of-week across long sessions. Neutral ISO-8601, no locale,