feat(context-engine): post-response grounding-enforcement hook

[arminanton]

Summary

Adds the host-side grounding-enforcement seam that a grounding-aware context
engine plugs into. After the assistant message is normalized in the conversation
loop, if the active context engine advertises an enforce_response capability
(via a capabilities() method returning {"enforce_response": True, ...}), the
engine may audit the final answer against its record and return a replacement
when the answer is ungrounded.

Design

• No-op by default. The built-in ContextCompressor and LCM have no
  capabilities() method, so they are entirely unaffected.
• Duck-typed. Uses getattr(_eng, "capabilities", None) + a callable check,
  so any engine lacking the API is silently skipped — no hard dependency on a
  particular engine being installed.
• Crash-safe. The whole block is wrapped; enforcement can never break a turn.
• Final text only. Skips tool-call turns and empty content.

This is the single host-side seam for a verbatim-memory / grounding context engine.
The engine implementation itself lives in its own component; this PR is just the
provider-agnostic hook in the conversation loop.

Tests

tests/agent/test_grounding_enforcement_hook.py (6 cases): replace verdict,
keep verdict, engine without capabilities() (no-op), no engine (no-op),
tool-call turn (skipped), empty content (skipped). All pass; ruff clean.

Built on origin/main; applies onto v0.17.0.

[alt-glitch]

Related: #50053 (the additive grounding hook points — capabilities()/pre_send/enforce_response — on the base ContextEngine ABC in agent/context_engine.py). This PR adds the complementary host-side call site in agent/conversation_loop.py that invokes enforce_response after the assistant message is normalized. Same author, different layer (ABC definition vs conversation-loop invocation) — companion, not a duplicate.

[arminanton]

Thanks @alt-glitch — correct, this is the conversation-loop call site invoking enforce_response after the assistant message is normalized, the companion to #50053's ABC hook-point definitions. Same author, different layer; complementary not duplicate.

[teknium1]

Thanks for the focused companion host hook. The underlying extension point is not on current main, so this remains useful work, but the draft needs relocation to match the current conversation-loop finalization path.

Problems

• The proposed post-normalization call is not final-only on current main: agent/conversation_loop.py:4387-4431 handles Codex finish_reason == "incomplete" after normalization and continues the turn. Calling the engine there with final=True can audit an intermediate response.
• Final text is assembled later: agent/conversation_loop.py:5137-5142 joins truncated parts and strips think blocks, and :5268 appends the final message. The proposed call would audit a fragment rather than the delivered result.
• tests/agent/test_grounding_enforcement_hook.py:14-30 mirrors the production block instead of invoking the conversation loop, so it cannot verify integration placement or persistence.

Suggested changes

• Rebase the implementation concept onto the current final-response path after final_response is composed at agent/conversation_loop.py:5137-5142 and before final-message construction/persistence.
• Add real run_conversation() coverage for replacement, incomplete-response skip, and length-continuation composition.
• Coordinate the capability/verdict API with companion PR #50053, which is still open.

Automated hermes-sweeper review.

[teknium1]

This runs immediately after normalization, but a normalized response is not necessarily final: current main continues Codex finish_reason == "incomplete" responses later in the loop. Move enforcement to the final-response path after continuation/recovery and response-part assembly, otherwise final=True can replace an intermediate answer.

[teknium1]

This helper mirrors the implementation, so these tests do not exercise the conversation-loop call site. Please drive run_conversation() with an opt-in fake engine to verify replacement is returned and persisted only for a completed final response.