feat(cron): mirror cron delivery output to target session for cross-session awareness

[zhangyu921]

Summary

When cron jobs autonomously deliver messages to a platform (telegram, discord, etc.), the receiving agent has no awareness that the message was sent — the cron output lives in the delivery channel but not in the agent's session transcript. This means the next time the user talks to the agent, it has no context of what cron just told them.

This is particularly impactful in persona-driven / SOUL.md scenarios: when an agent has a defined personality (like Asuka, a custom companion persona), cron-scheduled check-ins, market alerts, and daily briefings are delivered in-character. But when the user follows up on the same platform, the agent starts with a blank conversation — it doesn't know what its own persona just said via cron. The user has to repeat themselves or the agent has to manually call `session_search` to piece together context, breaking the natural flow of a persistent personality.

This PR bridges that gap by adding a `cron.mirror_to_session` option that mirrors cron delivery output into the target session's SQLite transcript, tagged with `mirror: true` and `mirror_source: "cron"`. On the user's next message, the agent sees `[Delivered from cron]` messages in conversation history — the personality stays continuous without manual lookup.

Changes

File	Change
`cron/scheduler.py`	Import `mirror_to_session`; call it after successful delivery in both the live-adapter and no-adapter fallback paths
`hermes_cli/config.py`	Add `mirror_to_session: false` default under `cron.settings` section with docstring
`gateway/mirror.py`	New module — `mirror_to_session()` finds the matching gateway session via sessions.json, then writes a delivery-mirror record (role=assistant, mirror=true, mirror_source=cron) to the SQLite session DB
`tests/gateway/test_mirror.py`	Tests for `_find_session_id` (platform matching, thread/user disambiguation, ambiguous-group safety), `mirror_to_session` (success, thread-aware, user-aware, missing-session, error), and `_append_to_sqlite` (connection lifecycle, error cleanup)

How it works

1. User enables `cron.mirror_to_session: true` in config.yaml
2. When a cron job fires and successfully delivers to a platform, `_deliver_result()` calls `mirror_to_session()` with the platform, chat_id, content, and source_label="cron"
3. `mirror_to_session()` resolves the session via sessions.json, then persists a mirror message to the SQLite transcript
4. On the user's next message, the prompt builder includes these mirror messages in conversation history — the agent sees them as if it had said them itself

Config

```yaml
cron:
mirror_to_session: true # default: false — backward compatible
```

How to test

1. Enable `cron.mirror_to_session: true` in `~/.hermes/config.yaml`
2. Create a cron job that delivers to your chat: `/cron create "every 1m" "Say hello from cron"`
3. Wait for delivery, then send any message — the agent should reference the cron message in context without needing `session_search`

Platforms tested

• macOS 14+ (local development)
• Linux (CI test suite)

Backward compatibility

Defaults to `false` — existing cron behaviour is unchanged. No new dependencies. The mirror function is non-fatal on error (all exceptions caught and logged at DEBUG level).

[Vantex]

+1 — WeChat daily driver, mirror approach is the right fit

+1 for this feature. I'm running Hermes on WeChat as a daily driver, and the cron context gap is a real pain point.

My use case: I have several cron jobs that deliver context summaries (daily diary reminders, wiki digestion results, project status updates) to my WeChat chat. When I reply to those messages, the main agent has zero context about what the cron just told me — it's a blank conversation. I end up having to manually paste context or re-explain.

Current workaround: I wrote a cron_output/ bridge — cron dumps its result to a JSON file, and my SOUL.md has a hardcoded rule that tells the agent to stat that file on every incoming message during specific time windows. It works but it's fragile, requires maintenance, and has timing edge cases.

What I want: When a cron job fires and delivers to my WeChat chat, the cron output should be visible to the agent in the session transcript on my next message. Exactly what cron.mirror_to_session describes.

WeChat-specific note: WeChat doesn't have Telegram-style inline buttons, so the offer_context_inject approach from #26206 wouldn't work here. The automatic mirror approach in #34631 is the better fit for platforms without rich message UI.

Happy to beta-test if this gets implemented.

[teknium1]

Thanks for the focused implementation and for documenting the WeChat use case in the discussion.

Automated hermes-sweeper review found this behavior is already implemented on current main:

• 1b181724fae7799cf45dec3aca03ac44063175e7 added opt-in cron-delivery mirroring via global cron.mirror_delivery and per-job attach_to_session controls.
• cron/scheduler.py:584 resolves that opt-in gate; cron/scheduler.py:1875 and cron/scheduler.py:1965 mirror after successful live-adapter and standalone deliveries.
• c06ceb3232f2df301077db891c4b416f3326efa8 scopes the mirror to the originating conversation, and b177d4ee4891aeb3bf8a908f6e5def846a55c180 makes the replay alternation-safe with a labelled user turn.
• Existing coverage in tests/cron/test_scheduler.py:4165 verifies the gate, origin-only targeting, user-id routing, and replay-role invariant.

The shipped implementation addresses the requested next-turn awareness while adding session-isolation and message-alternation safeguards, so this PR is now redundant.