feat(cron): bind scheduled automations to sessions

tests/agent/test_loop_save_turn.py

@@ -11,6 +11,7 @@ from nanobot.bus.queue import MessageBus
 from nanobot.providers.base import LLMResponse
 from nanobot.session.goal_state import GOAL_STATE_KEY
 from nanobot.session.manager import Session, SessionManager
+from nanobot.session.routing import SESSION_ROUTING_METADATA_KEY
 from nanobot.session.turn_continuation import (
     INTERNAL_CONTINUATION_META,
     INTERNAL_CONTINUATION_RUN_STARTED_AT_META,
@@ -827,6 +828,12 @@ async def test_process_message_uses_context_chat_id_for_runtime_prompt(tmp_path:
     assert result.chat_id == "thread-777"
     assert loop.context.build_messages.call_args.kwargs["chat_id"] == "parent-456"
     assert loop._run_agent_loop.call_args.kwargs["chat_id"] == "thread-777"
+    session = loop.sessions.get_or_create("discord:parent-456:thread:thread-777")
+    assert session.metadata[SESSION_ROUTING_METADATA_KEY] == {
+        "channel": "discord",
+        "chat_id": "thread-777",
+        "metadata": {"context_chat_id": "parent-456"},
+    }
 
 
 @pytest.mark.asyncio

tests/agent/test_runner_injections.py

@@ -616,6 +616,54 @@ async def test_followup_routed_to_pending_queue(tmp_path):
     assert queued_msg.session_key == UNIFIED_SESSION_KEY
 
 
+@pytest.mark.asyncio
+async def test_automation_turn_deferred_while_session_active(tmp_path):
+    """Automation turns wait for the active session instead of becoming injections."""
+    from nanobot.bus.events import InboundMessage
+    from nanobot.cron.automation import (
+        AUTOMATION_DEFER_UNTIL_IDLE_META,
+        AUTOMATION_TRIGGER_META,
+    )
+
+    loop = _make_loop(tmp_path)
+    loop._dispatch = AsyncMock()  # type: ignore[method-assign]
+
+    session_key = "websocket:chat-1"
+    pending = asyncio.Queue(maxsize=20)
+    loop._pending_queues[session_key] = pending
+
+    run_task = asyncio.create_task(loop.run())
+    msg = InboundMessage(
+        channel="websocket",
+        sender_id="cron",
+        chat_id="chat-1",
+        content="scheduled work",
+        metadata={
+            AUTOMATION_TRIGGER_META: {"run_id": "run-1"},
+            AUTOMATION_DEFER_UNTIL_IDLE_META: True,
+        },
+        session_key_override=session_key,
+    )
+    await loop.bus.publish_inbound(msg)
+
+    for _ in range(20):
+        if loop._deferred_automation_queues.get(session_key):
+            break
+        await asyncio.sleep(0.05)
+
+    loop.stop()
+    await asyncio.wait_for(run_task, timeout=2)
+
+    assert pending.empty()
+    assert loop._dispatch.await_count == 0
+    assert loop._deferred_automation_queues[session_key] == [msg]
+
+    await loop._publish_next_deferred_automation(session_key)
+    queued = await asyncio.wait_for(loop.bus.consume_inbound(), timeout=0.5)
+    assert queued is msg
+    assert session_key not in loop._deferred_automation_queues
+
+
 @pytest.mark.asyncio
 async def test_pending_queue_preserves_overflow_for_next_injection_cycle(tmp_path):
     """Pending queue should leave overflow messages queued for later drains."""

tests/agent/test_session_manager_history.py

@@ -1,4 +1,5 @@
 from nanobot.session.manager import Session, SessionManager
+from nanobot.session.routing import SESSION_ROUTING_METADATA_KEY
 
 
 def _assert_no_orphans(history: list[dict]) -> None:
@@ -432,6 +433,11 @@ def test_fork_session_before_user_index_copies_only_prefix(tmp_path):
     source.metadata["webui"] = True
     source.metadata["title"] = "Old title"
     source.metadata["goal_state"] = {"status": "active", "objective": "do not inherit"}
+    source.metadata[SESSION_ROUTING_METADATA_KEY] = {
+        "channel": "websocket",
+        "chat_id": "source",
+        "metadata": {},
+    }
     source.add_message("user", "round1")
     source.add_message("assistant", "answer1")
     source.add_message("user", "round2 fork me")
@@ -450,6 +456,7 @@ def test_fork_session_before_user_index_copies_only_prefix(tmp_path):
     assert forked.metadata["webui"] is True
     assert "title" not in forked.metadata
     assert "goal_state" not in forked.metadata
+    assert SESSION_ROUTING_METADATA_KEY not in forked.metadata
     saved = manager.read_session_file("websocket:fork")
     assert [m["content"] for m in saved["messages"]] == ["round1", "answer1"]
 

tests/channels/test_websocket_http_routes.py

@@ -188,6 +188,13 @@ async def test_session_automations_route_filters_by_webui_session(
             to=to,
             session_key=f"websocket:{to}",
         )
+    cron.add_job(
+        name="Legacy same target",
+        schedule=hourly,
+        message="Legacy job should not be treated as bound",
+        channel="websocket",
+        to="abc",
+    )
     cron.register_system_job(
         CronJob(
             id="heartbeat",
@@ -659,6 +666,91 @@ async def test_session_delete_removes_file(
         await server_task
 
 
+@pytest.mark.asyncio
+async def test_session_delete_blocks_when_bound_automation_exists(
+    bus: MagicMock, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)
+    sm = _seed_session(tmp_path, key="websocket:doomed")
+    cron = CronService(tmp_path / "cron" / "jobs.json")
+    cron.add_job(
+        name="Daily check",
+        schedule=CronSchedule(kind="every", every_ms=86_400_000),
+        message="Check the repo",
+        session_key="websocket:doomed",
+    )
+    channel = _ch(bus, session_manager=sm, cron_service=cron, port=29915)
+    server_task = asyncio.create_task(channel.start())
+    await asyncio.sleep(0.3)
+    try:
+        boot = await _http_get("http://127.0.0.1:29915/webui/bootstrap")
+        token = boot.json()["token"]
+        auth = {"Authorization": f"Bearer {token}"}
+
+        path = sm._get_session_path("websocket:doomed")
+        resp = await _http_get(
+            "http://127.0.0.1:29915/api/sessions/websocket:doomed/delete",
+            headers=auth,
+        )
+
+        assert resp.status_code == 200
+        body = resp.json()
+        assert body["deleted"] is False
+        assert body["blocked_by_automations"] is True
+        assert [job["name"] for job in body["automations"]] == ["Daily check"]
+        assert path.exists()
+        assert cron.list_bound_agent_jobs_for_session("websocket:doomed")
+    finally:
+        await channel.stop()
+        await server_task
+
+
+@pytest.mark.asyncio
+async def test_session_delete_can_cascade_bound_automations(
+    bus: MagicMock, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr("nanobot.config.paths.get_data_dir", lambda: tmp_path)
+    sm = _seed_session(tmp_path, key="websocket:doomed")
+    cron = CronService(tmp_path / "cron" / "jobs.json")
+    cron.add_job(
+        name="Daily check",
+        schedule=CronSchedule(kind="every", every_ms=86_400_000),
+        message="Check the repo",
+        session_key="websocket:doomed",
+    )
+    cron.add_job(
+        name="Legacy same target",
+        schedule=CronSchedule(kind="every", every_ms=86_400_000),
+        message="Legacy job remains",
+        channel="websocket",
+        to="doomed",
+    )
+    channel = _ch(bus, session_manager=sm, cron_service=cron, port=29916)
+    server_task = asyncio.create_task(channel.start())
+    await asyncio.sleep(0.3)
+    try:
+        boot = await _http_get("http://127.0.0.1:29916/webui/bootstrap")
+        token = boot.json()["token"]
+        auth = {"Authorization": f"Bearer {token}"}
+
+        path = sm._get_session_path("websocket:doomed")
+        resp = await _http_get(
+            "http://127.0.0.1:29916/api/sessions/websocket:doomed/delete?delete_automations=true",
+            headers=auth,
+        )
+
+        assert resp.status_code == 200
+        assert resp.json()["deleted"] is True
+        assert not path.exists()
+        assert cron.list_bound_agent_jobs_for_session("websocket:doomed") == []
+        assert [job.name for job in cron.list_jobs(include_disabled=True)] == [
+            "Legacy same target"
+        ]
+    finally:
+        await channel.stop()
+        await server_task
+
+
 @pytest.mark.asyncio
 async def test_session_routes_accept_percent_encoded_websocket_keys(
     bus: MagicMock, tmp_path: Path

tests/cli/test_commands.py

@@ -8,13 +8,14 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import pytest
 from typer.testing import CliRunner
 
-from nanobot.bus.events import OutboundMessage
+from nanobot.bus.events import InboundMessage, OutboundMessage
 from nanobot.cli.commands import _proactive_delivery_metadata, app
 from nanobot.config.schema import Config
 from nanobot.cron.types import CronJob, CronPayload
 from nanobot.providers.factory import ProviderSnapshot, make_provider
 from nanobot.providers.openai_codex_provider import _strip_model_prefix
 from nanobot.providers.registry import find_by_name
+from nanobot.session.routing import SESSION_ROUTING_METADATA_KEY
 
 runner = CliRunner()
 
@@ -1352,7 +1353,6 @@ def test_gateway_cron_evaluator_receives_scheduled_reminder_context(
                 "webui_turn_id": old_turn_id,
                 "workspace_scope": {"mode": "default"},
             },
-            session_key="websocket:chat-1",
         ),
     )
 
@@ -1373,6 +1373,175 @@ def test_gateway_cron_evaluator_receives_scheduled_reminder_context(
     }
 
 
+def test_gateway_bound_cron_runs_as_session_turn(
+    monkeypatch, tmp_path: Path
+) -> None:
+    config_file = tmp_path / "instance" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    config_file.write_text("{}")
+
+    config = Config()
+    config.agents.defaults.workspace = str(tmp_path / "config-workspace")
+    provider = _fake_provider()
+    bus = MagicMock()
+    bus.publish_outbound = AsyncMock()
+    seen: dict[str, object] = {"run_records": []}
+
+    monkeypatch.setattr("nanobot.config.loader.set_config_path", lambda _path: None)
+    monkeypatch.setattr("nanobot.config.loader.load_config", lambda _path=None: config)
+    monkeypatch.setattr("nanobot.cli.commands.sync_workspace_templates", lambda _path: None)
+    monkeypatch.setattr("nanobot.providers.factory.make_provider", lambda _config: provider)
+    monkeypatch.setattr(
+        "nanobot.providers.factory.build_provider_snapshot",
+        lambda _config: _test_provider_snapshot(provider, _config),
+    )
+    monkeypatch.setattr(
+        "nanobot.providers.factory.load_provider_snapshot",
+        lambda _config_path=None: _test_provider_snapshot(provider, config),
+    )
+    monkeypatch.setattr("nanobot.bus.queue.MessageBus", lambda: bus)
+
+    route_metadata = {
+        "websocket:chat-1": {
+            "workspace_scope": {
+                "project_path": str(tmp_path),
+                "access_mode": "restricted",
+            },
+            SESSION_ROUTING_METADATA_KEY: {
+                "channel": "websocket",
+                "chat_id": "chat-1",
+                "metadata": {},
+            },
+        },
+        "discord:456:thread:777": {
+            SESSION_ROUTING_METADATA_KEY: {
+                "channel": "discord",
+                "chat_id": "777",
+                "metadata": {
+                    "context_chat_id": "456",
+                    "parent_channel_id": "456",
+                    "thread_id": "777",
+                },
+            },
+        },
+    }
+
+    class _FakeSessionManager:
+        def __init__(self, _workspace: Path) -> None:
+            pass
+
+        def read_session_file(self, key: str) -> dict[str, object] | None:
+            return {"metadata": route_metadata.get(key, {})}
+
+    monkeypatch.setattr("nanobot.session.manager.SessionManager", _FakeSessionManager)
+
+    class _FakeCron:
+        def __init__(self, _store_path: Path) -> None:
+            self.on_job = None
+            seen["cron"] = self
+
+        def write_run_record(self, run_id: str, record: dict[str, object]) -> None:
+            seen["run_records"].append((run_id, record))
+
+    class _FakeAgentLoop:
+        @classmethod
+        def from_config(cls, config, bus=None, **extra):
+            return cls(**extra)
+
+        def __init__(self, *args, **kwargs) -> None:
+            self.model = "test-model"
+            self.provider = kwargs.get("provider", object())
+            self.tools = {}
+            seen["agent"] = self
+
+        async def submit_automation_turn(self, msg: InboundMessage):
+            seen["automation_msg"] = msg
+            return OutboundMessage(
+                channel=msg.channel,
+                chat_id=msg.chat_id,
+                content="Checked the repo.",
+            )
+
+        async def close_mcp(self) -> None:
+            return None
+
+        async def run(self) -> None:
+            return None
+
+        def stop(self) -> None:
+            return None
+
+    class _StopAfterCronSetup:
+        def __init__(self, *_args, **_kwargs) -> None:
+            raise _StopGatewayError("stop")
+
+    async def _unexpected_evaluator(*_args, **_kwargs) -> bool:
+        raise AssertionError("bound cron must not use legacy response evaluator")
+
+    monkeypatch.setattr("nanobot.cron.service.CronService", _FakeCron)
+    monkeypatch.setattr("nanobot.cli.commands.AgentLoop", _FakeAgentLoop)
+    monkeypatch.setattr("nanobot.channels.manager.ChannelManager", _StopAfterCronSetup)
+    monkeypatch.setattr("nanobot.cli.commands.evaluate_response", _unexpected_evaluator)
+
+    result = runner.invoke(app, ["gateway", "--config", str(config_file)])
+    assert isinstance(result.exception, _StopGatewayError)
+
+    cron = seen["cron"]
+    job = CronJob(
+        id="repo-check",
+        name="Repo check",
+        payload=CronPayload(
+            message="Check repository health.",
+            session_key="websocket:chat-1",
+        ),
+    )
+
+    response = asyncio.run(cron.on_job(job))
+
+    assert response == "Checked the repo."
+    msg = seen["automation_msg"]
+    assert isinstance(msg, InboundMessage)
+    assert msg.channel == "websocket"
+    assert msg.chat_id == "chat-1"
+    assert msg.sender_id == "cron"
+    assert msg.session_key_override == "websocket:chat-1"
+    assert "Automation: Check repository health." in msg.content
+    assert msg.metadata["webui"] is True
+    assert msg.metadata["workspace_scope"]["project_path"] == str(tmp_path)
+    assert msg.metadata["_webui_message_source"] == {"kind": "cron", "label": "Repo check"}
+    trigger = msg.metadata["_automation_trigger"]
+    assert trigger["job_id"] == "repo-check"
+    assert trigger["job_name"] == "Repo check"
+    assert trigger["persist_content"] == (
+        "Scheduled automation triggered: Repo check\n\nCheck repository health."
+    )
+    assert msg.metadata["_defer_until_session_idle"] is True
+    statuses = [record["status"] for _run_id, record in seen["run_records"]]
+    assert statuses == ["queued", "ok"]
+    assert seen["run_records"][0][0] == seen["run_records"][1][0]
+
+    discord_job = CronJob(
+        id="thread-check",
+        name="Thread check",
+        payload=CronPayload(
+            message="Check the Discord thread.",
+            session_key="discord:456:thread:777",
+        ),
+    )
+
+    response = asyncio.run(cron.on_job(discord_job))
+
+    assert response == "Checked the repo."
+    msg = seen["automation_msg"]
+    assert isinstance(msg, InboundMessage)
+    assert msg.channel == "discord"
+    assert msg.chat_id == "777"
+    assert msg.session_key_override == "discord:456:thread:777"
+    assert msg.metadata["context_chat_id"] == "456"
+    assert msg.metadata["parent_channel_id"] == "456"
+    assert msg.metadata["thread_id"] == "777"
+
+
 def test_gateway_cron_job_suppresses_intermediate_progress(
     monkeypatch, tmp_path: Path
 ) -> None:

tests/cron/test_cron_tool_list.py

@@ -303,7 +303,9 @@ def test_remove_protected_dream_job_returns_clear_feedback(tmp_path) -> None:
 
 def test_add_cron_job_defaults_to_tool_timezone(tmp_path) -> None:
     tool = _make_tool_with_tz(tmp_path, "Asia/Shanghai")
-    tool.set_context(RequestContext(channel="telegram", chat_id="chat-1"))
+    tool.set_context(
+        RequestContext(channel="telegram", chat_id="chat-1", session_key="telegram:chat-1")
+    )
 
     result = tool._add_job(None, "Morning standup", None, "0 8 * * *", None, None)
 
@@ -314,7 +316,9 @@ def test_add_cron_job_defaults_to_tool_timezone(tmp_path) -> None:
 
 def test_add_at_job_uses_default_timezone_for_naive_datetime(tmp_path) -> None:
     tool = _make_tool_with_tz(tmp_path, "Asia/Shanghai")
-    tool.set_context(RequestContext(channel="telegram", chat_id="chat-1"))
+    tool.set_context(
+        RequestContext(channel="telegram", chat_id="chat-1", session_key="telegram:chat-1")
+    )
 
     result = tool._add_job(None, "Morning reminder", None, None, None, "2026-03-25T08:00:00")
 
@@ -324,26 +328,29 @@ def test_add_at_job_uses_default_timezone_for_naive_datetime(tmp_path) -> None:
     assert job.schedule.at_ms == expected
 
 
-def test_add_job_delivers_by_default(tmp_path) -> None:
+def test_add_job_binds_current_session_key(tmp_path) -> None:
     tool = _make_tool(tmp_path)
-    tool.set_context(RequestContext(channel="telegram", chat_id="chat-1"))
+    tool.set_context(
+        RequestContext(channel="telegram", chat_id="chat-1", session_key="telegram:chat-1")
+    )
 
     result = tool._add_job(None, "Morning standup", 60, None, None, None)
 
     assert result.startswith("Created job")
     job = tool._cron.list_jobs()[0]
-    assert job.payload.deliver is True
+    assert job.payload.session_key == "telegram:chat-1"
+    assert job.payload.channel is None
+    assert job.payload.to is None
 
 
-def test_add_job_can_disable_delivery(tmp_path) -> None:
+def test_add_job_requires_session_key(tmp_path) -> None:
     tool = _make_tool(tmp_path)
     tool.set_context(RequestContext(channel="telegram", chat_id="chat-1"))
 
     result = tool._add_job(None, "Background refresh", 60, None, None, None, deliver=False)
 
-    assert result.startswith("Created job")
-    job = tool._cron.list_jobs()[0]
-    assert job.payload.deliver is False
+    assert result == "Error: scheduled automations must be created from a chat session"
+    assert tool._cron.list_jobs() == []
 
 
 def test_cron_schema_advertises_action_specific_requirements(tmp_path) -> None:
@@ -375,7 +382,9 @@ def test_validate_params_requires_message_only_for_add(tmp_path) -> None:
 
 def test_add_job_empty_message_returns_actionable_error(tmp_path) -> None:
     tool = _make_tool(tmp_path)
-    tool.set_context(RequestContext(channel="telegram", chat_id="chat-1"))
+    tool.set_context(
+        RequestContext(channel="telegram", chat_id="chat-1", session_key="telegram:chat-1")
+    )
 
     result = tool._add_job(None, "", 60, None, None, None)
 
@@ -383,8 +392,8 @@ def test_add_job_empty_message_returns_actionable_error(tmp_path) -> None:
     assert "Retry including message=" in result
 
 
-def test_add_job_captures_metadata_and_session_key(tmp_path) -> None:
-    """CronTool stores channel metadata and session_key when adding a job."""
+def test_add_job_captures_only_session_key(tmp_path) -> None:
+    """CronTool stores the canonical session key without legacy delivery fields."""
     tool = _make_tool(tmp_path)
     meta = {"slack": {"thread_ts": "111.222", "channel_type": "channel"}}
     tool.set_context(RequestContext(
@@ -396,8 +405,10 @@ def test_add_job_captures_metadata_and_session_key(tmp_path) -> None:
 
     jobs = tool._cron.list_jobs()
     assert len(jobs) == 1
-    assert jobs[0].payload.channel_meta == meta
     assert jobs[0].payload.session_key == "slack:C99:111.222"
+    assert jobs[0].payload.channel is None
+    assert jobs[0].payload.to is None
+    assert jobs[0].payload.channel_meta == {}
 
 
 def test_list_excludes_disabled_jobs(tmp_path) -> None:

tests/cron/test_cron_tool_schema_contract.py

@@ -41,7 +41,9 @@ class _SvcStub:
 @pytest.fixture
 def registry() -> ToolRegistry:
     tool = CronTool(_SvcStub(), default_timezone="UTC")
-    tool.set_context(RequestContext(channel="channel", chat_id="chat-id"))
+    tool.set_context(
+        RequestContext(channel="channel", chat_id="chat-id", session_key="channel:chat-id")
+    )
     reg = ToolRegistry()
     reg.register(tool)
     return reg

tests/session/test_routing.py

@@ -0,0 +1,53 @@
+from nanobot.bus.events import InboundMessage
+from nanobot.session.routing import routing_context_for_message
+
+
+def test_routing_context_keeps_telegram_topic_without_stale_message_id() -> None:
+    context = routing_context_for_message(
+        InboundMessage(
+            channel="telegram",
+            sender_id="user-1",
+            chat_id="-100123",
+            content="set a reminder",
+            metadata={
+                "message_id": 100,
+                "message_thread_id": 42,
+                "_progress": True,
+            },
+            session_key_override="telegram:-100123:topic:42",
+        )
+    )
+
+    assert context == {
+        "channel": "telegram",
+        "chat_id": "-100123",
+        "metadata": {"message_thread_id": 42},
+    }
+
+
+def test_routing_context_keeps_feishu_topic_anchor() -> None:
+    context = routing_context_for_message(
+        InboundMessage(
+            channel="feishu",
+            sender_id="ou_user",
+            chat_id="oc_chat",
+            content="set a reminder",
+            metadata={
+                "chat_type": "group",
+                "message_id": "om_msg",
+                "thread_id": "omt_thread",
+                "_progress": True,
+            },
+            session_key_override="feishu:oc_chat:om_root",
+        )
+    )
+
+    assert context == {
+        "channel": "feishu",
+        "chat_id": "oc_chat",
+        "metadata": {
+            "chat_type": "group",
+            "message_id": "om_msg",
+            "thread_id": "omt_thread",
+        },
+    }

tests/test_tool_contextvars.py

@@ -99,14 +99,18 @@ async def test_cron_tool_keeps_task_local_context(tmp_path) -> None:
     release = asyncio.Event()
 
     async def task_one() -> str:
-        tool.set_context(RequestContext(channel="feishu", chat_id="chat-a"))
+        tool.set_context(
+            RequestContext(channel="feishu", chat_id="chat-a", session_key="feishu:chat-a")
+        )
         entered.set()
         await release.wait()
         return await tool.execute(action="add", message="first", every_seconds=60)
 
     async def task_two() -> str:
         await entered.wait()
-        tool.set_context(RequestContext(channel="email", chat_id="chat-b"))
+        tool.set_context(
+            RequestContext(channel="email", chat_id="chat-b", session_key="email:chat-b")
+        )
         release.set()
         return await tool.execute(action="add", message="second", every_seconds=60)
 
@@ -116,8 +120,7 @@ async def test_cron_tool_keeps_task_local_context(tmp_path) -> None:
     assert result_two.startswith("Created job")
 
     jobs = tool._cron.list_jobs()
-    assert {job.payload.channel for job in jobs} == {"feishu", "email"}
-    assert {job.payload.to for job in jobs} == {"chat-a", "chat-b"}
+    assert {job.payload.session_key for job in jobs} == {"feishu:chat-a", "email:chat-b"}
 
 
 # --- Basic single-task regression tests ---
@@ -228,15 +231,16 @@ async def test_spawn_tool_default_values_without_set_context() -> None:
 async def test_cron_tool_basic_set_context_and_execute(tmp_path) -> None:
     """Single task: set_context then add job should use correct target."""
     tool = CronTool(CronService(tmp_path / "jobs.json"))
-    tool.set_context(RequestContext(channel="wechat", chat_id="user-789"))
+    tool.set_context(
+        RequestContext(channel="wechat", chat_id="user-789", session_key="wechat:user-789")
+    )
 
     result = await tool.execute(action="add", message="standup", every_seconds=300)
     assert result.startswith("Created job")
 
     jobs = tool._cron.list_jobs()
     assert len(jobs) == 1
-    assert jobs[0].payload.channel == "wechat"
-    assert jobs[0].payload.to == "user-789"
+    assert jobs[0].payload.session_key == "wechat:user-789"
 
 
 @pytest.mark.asyncio
@@ -245,4 +249,4 @@ async def test_cron_tool_no_context_returns_error(tmp_path) -> None:
     tool = CronTool(CronService(tmp_path / "jobs.json"))
 
     result = await tool.execute(action="add", message="test", every_seconds=60)
-    assert result == "Error: no session context (channel/chat_id)"
+    assert result == "Error: scheduled automations must be created from a chat session"