[codex] Fix empty gateway session hiding messaging history

[junjunjunbong]

Summary

• Narrow messaging stale-session filtering to active gateway sessions that are present in the current sidebar candidate set.
• Preserve older messaging history when the gateway advertises a fresh zero-message session that is not visible yet.
• Add a regression test for an empty active Discord gateway row.

Root cause

When the gateway advertised a fresh Discord session in sessions.json, the sidebar treated that source as active and hid older Discord rows as stale. If the fresh session had zero messages, it was omitted from the visible session projection, leaving no Discord rows visible.

Validation

• /Users/junwon/.hermes/hermes-agent/venv/bin/python -m pytest tests/test_gateway_sync.py

[nesquena-hermes]

@nesquena Ready for independent review when you have a moment. CI is green; staging this for the next batch release once approved.

[nesquena]

Review — end-to-end ✅ (approved after rebase)

First — thanks for the contribution, @junjunjunbong! This is a clean, narrow fix to a real sidebar-projection bug with the right test scope.

What this ships

When _keep_latest_messaging_session_per_source() computes "which messaging sources have an active Gateway session," it used to treat every entry in sessions/sessions.json as active — even Gateway sessions that weren't actually present in the input rows (e.g. because they were filtered upstream for having zero messages). The fix intersects gateway-metadata session IDs with the currently visible row IDs, so the "this source is active, hide older rows" logic only fires when the active session is something the sidebar can actually show.

Note: the branch was stale (rebased onto current master)

The PR was opened 2026-05-15 against master @ stage-353 (v0.51.60-era). Master is now at v0.51.89; the _keep_latest_messaging_session_per_source block had moved + neighbouring tests had grown. I rebased the branch and resolved one keep-both conflict in tests/test_gateway_sync.py (your new test sat in the same insertion gap as an email-source test added later in #2349/stage-360-ish). Now at 98f2814e. CI re-ran green on 3.11/3.12/3.13 after I approved the workflow.

Traced against upstream hermes-agent

Pulled a fresh nousresearch/hermes-agent tarball. Grep for _keep_latest_messaging_session_per_source and gateway_session_identity_map in hermes_cli/: no CLI counterpart. The gateway-sessions read pipeline is purely WebUI sidebar projection — Hermes Gateway writes sessions/sessions.json and WebUI reads it; the agent runtime itself doesn't touch this surface. No cross-tool contract to break. ✓

End-to-end trace

Setup (api/routes.py:2162-2176):

gateway_metadata = _load_gateway_session_identity_map()             # all gateway-known sessions
active_gateway_session_ids = {str(sid) for sid in gateway_metadata.keys() if sid}
session_ids = {                                                      # NEW: input-row IDs
    _safe_first(session.get("session_id"))
    for session in sessions
    if isinstance(session, dict)
}
visible_active_gateway_session_ids = active_gateway_session_ids & session_ids  # NEW: intersection
active_gateway_sources = {
    _normalize_messaging_source(_safe_first(meta.get("raw_source"), meta.get("platform")))
    for sid, meta in gateway_metadata.items()
    if sid in visible_active_gateway_session_ids and isinstance(meta, dict)   # NEW: scoped to visible
}

Hide check (api/routes.py:2186): _should_hide_stale_messaging_session(session, visible_active_gateway_session_ids, active_gateway_sources) — now receives only the gateway sessions that exist in the input rows, plus the sources that those visible sessions belong to.

Why this fixes the bug: _should_hide_stale_messaging_session at api/routes.py:1878-1916 bails out early (return False) unless raw_source in active_gateway_sources. If the only gateway-advertised Discord session is invisible (e.g. zero messages, filtered upstream), active_gateway_sources no longer contains "discord", so older Discord history rows are no longer flagged stale. The downstream staleness predicates (end_reason in _STALE_MESSAGING_END_REASONS, parent_session_id, message_count <= 0) only fire when there's a legitimate active Gateway row to defer to.

Behavioral harness (semantic correctness)

To prove the fix doesn't regress the legitimate "hide stale rows when an active Gateway session IS visible" case, I built a 6-scenario Python harness exercising the helper directly:

ok    empty active gateway session — older Discord history preserved        (PR's regression)
ok    gateway active session visible — older stale Discord row hidden       (original use case)
ok    gateway has discord+slack, only slack visible — older Discord preserved
ok    no gateway metadata — fallback keeps history
ok    empty rows list — empty result
ok    non-messaging sessions passthrough — webui session always kept
=== Overall: ALL PASS

Scenario 2 is the load-bearing one: when the active Gateway session IS in the rows, visible_active_gateway_session_ids correctly contains it, active_gateway_sources = {"discord"}, and older session_reset rows are hidden exactly as before. Behaviour is preserved.

Edge-case matrix

Scenario	Expected	Actual
Empty sessions list	empty result	✅
Empty gateway metadata	all rows kept (fallback)	✅
Gateway active session visible + stale older row	active kept, stale hidden	✅ (unchanged from before fix)
Gateway active session invisible + history row	history preserved	✅ (the fix; was hidden before)
Gateway has discord+slack, only slack visible, older Discord row present	older Discord preserved (discord source no longer "active")	✅
Non-messaging session (webui)	always kept	✅
Session with no session_id	_safe_first(None) → None; harmless (not in active_gateway_session_ids either)	✅
Cross-tool (CLI reads same sessions.json)	no CLI consumer of this WebUI-only projection	✅

Other audit — things that are correct already

• Security: zero new surface. The helper reads from sessions/sessions.json (gateway-owned), filters input rows, and returns a projection. No user input controls anything; no auth, file IO, or HTTP changes.
• Test scope is exactly right. test_empty_active_gateway_session_does_not_hide_messaging_history exercises the helper through its monkeypatched gateway-identity-map input — directly tests the regression without coupling to upstream filesystem state. Asserts the projected session_id list, not just count.
• Existing tests preserved:
  • test_messaging_projection_does_not_aggressively_hide_without_gateway_metadata still passes — confirms no-gateway-metadata fallback unchanged.
  • test_messaging_projection_keeps_distinct_active_gateway_conversations still passes — confirms multi-source visible-active scenarios unchanged.

Tests

• tests/test_gateway_sync.py — 53 passed in 1.25s (the PR's new test included)
• Full suite — 5828 passed, 63 skipped, 0 failed in 54.25s
• Behavioral harness — 6/6 scenarios pass (including the legitimate hide-stale case)
• CI after rebase: test (3.11/3.12/3.13) all green

Minor observations (non-blocking)

• Variable naming is consistent with the rest of the file: _visible_active_* for the filtered set, original name retained for the unfiltered set. Reads clearly.
• The fix is fully backwards-compatible for the no-gateway-metadata path: when gateway_metadata is empty, active_gateway_session_ids = {} and so visible_active_gateway_session_ids = {} & session_ids = {} — same as before for the downstream check (not active_gateway_session_ids short-circuits at api/routes.py:1895).
• No CHANGELOG entry was added with the PR. Not blocking — release agent stages typically write these on the merge sweep.

Recommendation

✅ Approved. Parked at approval — ready for the release agent's merge/tag pipeline.

Thanks again for narrowing this from "treat all gateway-metadata sources as active" to "only the sources whose advertised sessions are actually visible." That's the right design — the upstream filter (zero-message hiding, whatever it is) shouldn't silently cascade into "hide history under that source too."