fix(honcho): honcho_search returns empty in directional observation mode

[keislij]

Summary

honcho_search returns empty for every query in directional observation mode (the default), even when Honcho has rich data about the user. honcho_profile, honcho_context, and honcho_reasoning all work — only honcho_search comes back empty.

Root cause

In directional mode, _resolve_observer_target("user") resolves to observer=assistant, target=user, so search_context() queries the assistant→user directional slot via peer.context(target=user, search_query=...).

That slot is only populated when conclusions are written through the directional path (create_conclusion in directional mode). But the user's substantive data — the auto-derived representation and peer card — lives on the user peer's own self-representation, which Honcho builds from the message stream. So the directional fetch returns empty and search_context() returns "".

get_peer_card() already anticipates exactly this split and has a target-peer fallback (added in a118b94):

# Some backends store cards directly on the target peer, not the
# observer-target slot. Fall back so honcho_profile still works.
if target_peer_id:
    return self._fetch_peer_card(target_peer_id)

search_context() was missing the equivalent fallback, which is why honcho_profile works but honcho_search doesn't.

Fix

Mirror the get_peer_card() fallback in search_context(): when the directional fetch yields no representation and no card, refetch the target peer's own self-context.

if not ctx["representation"] and not ctx["card"] and target and target != observer_peer_id:
    ctx = self._fetch_peer_context(target, search_query=query)

• Preserves directional precedence — the observer→target slot is still tried first, so if it's populated it wins.
• No-op for the ai peer path, where observer == target (the condition short-circuits).
• 6 lines, no new mechanism — reuses the existing _fetch_peer_context helper and matches the pattern already shipping in get_peer_card.

Validation

Reproduced against a live Honcho cloud workspace in directional mode. Before the fix, peer.context(target=user, search_query=q) returns representation len: 0 for every query. The user's own peer.context(search_query=q) returns 1840–2949 chars for the same queries. After the fix, honcho_search returns those results.

New regression test test_search_context_falls_back_to_target_self_context_when_directional_empty covers the directional-empty → user-self-context fallback (parallel to the existing test_get_peer_card_falls_back_to_target_peer_own_card).

pytest tests/honcho_plugin/test_session.py -k "search_context or peer_card" -q
9 passed

Full tests/honcho_plugin/test_session.py passes. (3 unrelated failures in test_pin_peer_name.py::TestPinTransition are pre-existing on main — confirmed by stashing this change and re-running; they concern cache-busting signatures, not retrieval.)

Prior art

This is a recurrence of the symptom from #5667 / PR #5658 ("align honcho_search retrieval with observation direction"), which was closed unmerged and superseded by the tool-surface overhaul in #10619. That overhaul absorbed the target= plumbing but dropped the fallback, reintroducing empty results for users whose data is Honcho-derived rather than written via honcho_conclude. This fix restores read/write alignment while also covering the auto-derived-representation case that #5658 would not have (it read the directional slot only).

[Copilot]

Pull request overview

Fixes honcho_search returning empty results in Honcho “directional observation mode” by adding a fallback: when the observer→target slot yields neither representation nor card, refetch the target peer’s own self-context (mirroring the existing get_peer_card() fallback behavior). This aligns honcho_search with how Honcho-derived (auto-built) user representations are actually stored.

Changes:

• Add a fallback in HonchoSessionManager.search_context() to query the target peer’s self-context when the directional observer→target context is empty.
• Add a regression test covering the “directional empty → target self-context” fallback behavior.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
plugins/memory/honcho/session.py	Adds a guarded fallback in search_context() to retrieve target peer self-context when directional context is empty.
tests/honcho_plugin/test_session.py	Adds a regression test validating the fallback behavior and call ordering.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[teknium1]

Thanks for the focused regression fix. Current main still routes honcho_search through only the observer-target slot in plugins/memory/honcho/session.py:1133-1146; the function has no target-peer self-context fallback. In contrast, get_peer_card() already implements the corresponding compatibility fallback at plugins/memory/honcho/session.py:1092-1100.

The proposed conditional fallback preserves the existing directional result when populated and avoids a duplicate self-fetch for the assistant peer. The added tests cover both the empty directional slot and the no-fallback populated case. gh pr view 48602 reports the branch as mergeable against current main.

Automated hermes-sweeper review.

[teknium1]

Superseded on main by #62290 (commit 8d1c96f): honcho_search was rewritten to do real cross-session message search via honcho.search() with a char budget — it no longer reads the directional observer→target representation slot at all, so the empty-directional-mode bug this PR patched can no longer occur. Thanks @keislij for the diagnosis and fix; the mechanism it targeted was replaced wholesale.