rename from checkpoint to timeline agent

tests/conftest.py

@@ -129,12 +129,12 @@ _SEED_PLUGINS = [
     Plugin(
         id="plugin-slack-notify",
         name="Slack Notifier",
-        description="Post task and checkpoint updates to Slack channels.",
+        description="Post task and timeline updates to Slack channels.",
         version="1.2.0",
         author_name="Adiuva",
         category="communication",
         price_cents=499,
-        permissions=json.dumps(["read:tasks", "read:checkpoints"]),
+        permissions=json.dumps(["read:tasks", "read:timelines"]),
         status="approved",
         s3_package_key="plugins/plugin-slack-notify/1.2.0/package.zip",
         install_count=0,

tests/test_agents.py

@@ -9,7 +9,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import pytest
 
 import app.agents  # noqa: F401 — triggers @registry.register decorators
-from app.agents.checkpoint_agent import CheckpointAgent
+from app.agents.timeline_agent import TimelineAgent
 from app.agents.note_agent import NoteAgent
 from app.agents.project_agent import ProjectAgent
 from app.agents.task_agent import TaskAgent
@@ -110,12 +110,12 @@ class TestAgentRegistration:
     def test_all_agents_registered(self) -> None:
         names = {a["name"] for a in registry.list_agents()}
         assert {
-            "task_agent", "checkpoint_agent", "project_agent", "note_agent"
+            "task_agent", "timeline_agent", "project_agent", "note_agent"
         }.issubset(names)
 
     def test_registry_returns_correct_types(self) -> None:
         assert isinstance(registry.get("task_agent"), TaskAgent)
-        assert isinstance(registry.get("checkpoint_agent"), CheckpointAgent)
+        assert isinstance(registry.get("timeline_agent"), TimelineAgent)
         assert isinstance(registry.get("project_agent"), ProjectAgent)
         assert isinstance(registry.get("note_agent"), NoteAgent)
 
@@ -336,94 +336,94 @@ class TestTaskAgentTools:
         assert "c1" in result
 
 
-# ── CheckpointAgent ───────────────────────────────────────────────────
+# ── TimelineAgent ───────────────────────────────────────────────────
 
 
-class TestCheckpointAgent:
+class TestTimelineAgent:
     def test_name(self) -> None:
-        assert CheckpointAgent().get_name() == "checkpoint_agent"
+        assert TimelineAgent().get_name() == "timeline_agent"
 
     def test_description(self) -> None:
-        assert CheckpointAgent().get_description() == "Manages project checkpoints (milestones): list, create, update, delete"
+        assert TimelineAgent().get_description() == "Manages project timelines (milestones): list, create, update, delete"
 
     def test_get_tools_count(self) -> None:
-        assert len(CheckpointAgent().get_tools()) == 4
+        assert len(TimelineAgent().get_tools()) == 4
 
     def test_tool_names(self) -> None:
-        names = {t.name for t in CheckpointAgent().get_tools()}
-        assert names == {"list_checkpoints", "create_checkpoint", "update_checkpoint", "delete_checkpoint"}
+        names = {t.name for t in TimelineAgent().get_tools()}
+        assert names == {"list_timelines", "create_timeline", "update_timeline", "delete_timeline"}
 
     @pytest.mark.asyncio
     async def test_handle_no_tool_calls(self) -> None:
-        with patch("app.agents.checkpoint_agent.get_llm") as mock_cls:
-            mock_cls.return_value = _mock_llm("No checkpoints found.")
-            result = await CheckpointAgent().handle("list checkpoints", {})
-        assert result == "No checkpoints found."
+        with patch("app.agents.timeline_agent.get_llm") as mock_cls:
+            mock_cls.return_value = _mock_llm("No timelines found.")
+            result = await TimelineAgent().handle("list timelines", {})
+        assert result == "No timelines found."
 
     @pytest.mark.asyncio
     async def test_handle_with_create_tool_call(self) -> None:
-        with patch("app.agents.checkpoint_agent.get_llm") as mock_cls:
+        with patch("app.agents.timeline_agent.get_llm") as mock_cls:
             mock_cls.return_value = _mock_llm_with_tool_call(
-                "create_checkpoint",
+                "create_timeline",
                 {"project_id": "p1", "title": "MVP Launch", "date": 1700000000000},
-                "Checkpoint 'MVP Launch' created.",
+                "Timeline 'MVP Launch' created.",
             )
-            result = await CheckpointAgent().handle("add MVP checkpoint", {})
-        assert result == "Checkpoint 'MVP Launch' created."
+            result = await TimelineAgent().handle("add MVP timeline", {})
+        assert result == "Timeline 'MVP Launch' created."
 
     @pytest.mark.asyncio
     async def test_handle_accepts_empty_context(self) -> None:
-        with patch("app.agents.checkpoint_agent.get_llm") as mock_cls:
+        with patch("app.agents.timeline_agent.get_llm") as mock_cls:
             mock_cls.return_value = _mock_llm("Done.")
-            result = await CheckpointAgent().handle("show milestones", {})
+            result = await TimelineAgent().handle("show milestones", {})
         assert isinstance(result, str)
 
 
-class TestCheckpointAgentTools:
+class TestTimelineAgentTools:
     @pytest.mark.asyncio
-    async def test_list_checkpoints_no_project(self) -> None:
-        from app.agents.checkpoint_agent import list_checkpoints
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+    async def test_list_timelines_no_project(self) -> None:
+        from app.agents.timeline_agent import list_timelines
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"rows": []}
-            result = await list_checkpoints.ainvoke({})
+            result = await list_timelines.ainvoke({})
         call_kwargs = m.call_args.kwargs
         assert call_kwargs["action"] == "select"
-        assert call_kwargs["table"] == "checkpoints"
+        assert call_kwargs["table"] == "timelines"
         assert call_kwargs["filters"]["projectId"] is None
-        assert result == "No checkpoints found."
+        assert result == "No timelines found."
 
     @pytest.mark.asyncio
-    async def test_list_checkpoints_with_project(self) -> None:
-        from app.agents.checkpoint_agent import list_checkpoints
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+    async def test_list_timelines_with_project(self) -> None:
+        from app.agents.timeline_agent import list_timelines
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"rows": []}
-            await list_checkpoints.ainvoke({"project_id": "p1"})
+            await list_timelines.ainvoke({"project_id": "p1"})
         assert m.call_args.kwargs["filters"]["projectId"] == "p1"
 
     @pytest.mark.asyncio
-    async def test_create_checkpoint(self) -> None:
-        from app.agents.checkpoint_agent import create_checkpoint
+    async def test_create_timeline(self) -> None:
+        from app.agents.timeline_agent import create_timeline
         fake_row = {"id": "cp1", "title": "Beta release", "date": 1700000000000}
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"row": fake_row}
-            result = await create_checkpoint.ainvoke({
+            result = await create_timeline.ainvoke({
                 "project_id": "p1", "title": "Beta release", "date": 1700000000000,
             })
         call_kwargs = m.call_args.kwargs
         assert call_kwargs["action"] == "insert"
-        assert call_kwargs["table"] == "checkpoints"
+        assert call_kwargs["table"] == "timelines"
         assert call_kwargs["data"]["projectId"] == "p1"
         assert call_kwargs["data"]["title"] == "Beta release"
         assert call_kwargs["data"]["date"] == 1700000000000
         assert "Beta release" in result
 
     @pytest.mark.asyncio
-    async def test_create_checkpoint_ai_suggested(self) -> None:
-        from app.agents.checkpoint_agent import create_checkpoint
+    async def test_create_timeline_ai_suggested(self) -> None:
+        from app.agents.timeline_agent import create_timeline
         fake_row = {"id": "cp1", "title": "Review", "date": 1700000000000}
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"row": fake_row}
-            await create_checkpoint.ainvoke({
+            await create_timeline.ainvoke({
                 "project_id": "p1", "title": "Review", "date": 1700000000000, "is_ai_suggested": 1,
             })
         call_kwargs = m.call_args.kwargs
@@ -431,12 +431,12 @@ class TestCheckpointAgentTools:
         assert call_kwargs["data"]["isApproved"] == 0
 
     @pytest.mark.asyncio
-    async def test_update_checkpoint_approve(self) -> None:
-        from app.agents.checkpoint_agent import update_checkpoint
+    async def test_update_timeline_approve(self) -> None:
+        from app.agents.timeline_agent import update_timeline
         fake_row = {"id": "c1", "title": "MVP", "isApproved": 1}
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"row": fake_row}
-            result = await update_checkpoint.ainvoke({"checkpoint_id": "c1", "is_approved": 1})
+            result = await update_timeline.ainvoke({"timeline_id": "c1", "is_approved": 1})
         call_kwargs = m.call_args.kwargs
         assert call_kwargs["action"] == "update"
         assert call_kwargs["data"]["id"] == "c1"
@@ -444,23 +444,23 @@ class TestCheckpointAgentTools:
         assert "c1" in result
 
     @pytest.mark.asyncio
-    async def test_update_checkpoint_empty_updates(self) -> None:
-        from app.agents.checkpoint_agent import update_checkpoint
+    async def test_update_timeline_empty_updates(self) -> None:
+        from app.agents.timeline_agent import update_timeline
         fake_row = {"id": "c1", "title": "MVP"}
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"row": fake_row}
-            await update_checkpoint.ainvoke({"checkpoint_id": "c1"})
+            await update_timeline.ainvoke({"timeline_id": "c1"})
         assert m.call_args.kwargs["data"]["updates"] == {}
 
     @pytest.mark.asyncio
-    async def test_delete_checkpoint(self) -> None:
-        from app.agents.checkpoint_agent import delete_checkpoint
-        with patch("app.agents.checkpoint_agent.execute_on_client", new_callable=AsyncMock) as m:
+    async def test_delete_timeline(self) -> None:
+        from app.agents.timeline_agent import delete_timeline
+        with patch("app.agents.timeline_agent.execute_on_client", new_callable=AsyncMock) as m:
             m.return_value = {"deleted": True}
-            result = await delete_checkpoint.ainvoke({"checkpoint_id": "c1"})
+            result = await delete_timeline.ainvoke({"timeline_id": "c1"})
         call_kwargs = m.call_args.kwargs
         assert call_kwargs["action"] == "delete"
-        assert call_kwargs["table"] == "checkpoints"
+        assert call_kwargs["table"] == "timelines"
         assert call_kwargs["data"]["id"] == "c1"
         assert "c1" in result
 

tests/test_execution_plan.py

@@ -243,7 +243,7 @@ class TestPlanCache:
 
 class TestModuleSingletons:
     def test_template_registry_has_all_agent_defaults(self) -> None:
-        for agent in ("task_agent", "checkpoint_agent", "project_agent", "note_agent"):
+        for agent in ("task_agent", "timeline_agent", "project_agent", "note_agent"):
             assert template_registry.has(f"tpl_{agent}_default"), (
                 f"Missing template: tpl_{agent}_default"
             )

tests/test_orchestrator_v3.py

@@ -94,13 +94,13 @@ async def test_orchestrate_v3_uses_default_registry_when_none():
 
 @pytest.mark.asyncio
 async def test_orchestrate_v3_get_called_with_agent_name():
-    agent = _FixedAgent("checkpoint_agent")
-    reg = _make_registry("checkpoint_agent", agent)
+    agent = _FixedAgent("timeline_agent")
+    reg = _make_registry("timeline_agent", agent)
 
-    with patch("app.core.orchestrator.classify_intent", AsyncMock(return_value="checkpoint_agent")):
+    with patch("app.core.orchestrator.classify_intent", AsyncMock(return_value="timeline_agent")):
         await orchestrate_v3(user_id="u-2", message="schedule", context={}, reg=reg)
 
-    reg.get.assert_called_once_with("checkpoint_agent")
+    reg.get.assert_called_once_with("timeline_agent")
 
 
 # ── orchestrate_v3_stream ─────────────────────────────────────────────

tests/test_output_formatter.py

@@ -115,7 +115,7 @@ async def test_home_formatter_table_block():
 @pytest.mark.asyncio
 async def test_home_formatter_timeline_block():
     req_id = "req-7"
-    timeline_json = '{"type": "timeline", "checkpoints": [{"id": "c1", "title": "M1", "date": 123}]}'
+    timeline_json = '{"type": "timeline", "timelines": [{"id": "c1", "title": "M1", "date": 123}]}'
     formatter = HomeFormatter(request_id=req_id, tool_results=[])
     frames = await collect(formatter, _stream(("task_agent", timeline_json)))
 
@@ -156,11 +156,11 @@ async def test_floating_formatter_domain_emitted_first():
 async def test_floating_formatter_text_only():
     req_id = "pop-2"
     formatter = FloatingFormatter(request_id=req_id)
-    tokens = [("checkpoint_agent", ""), ("checkpoint_agent", "Summary")]
+    tokens = [("timeline_agent", ""), ("timeline_agent", "Summary")]
     frames = await collect(formatter, _stream(*tokens))
 
     assert isinstance(frames[0], WsFloatingDomain)
-    assert frames[0].domain == "checkpoints"
+    assert frames[0].domain == "timelines"
     text_frames = [f for f in frames if isinstance(f, WsStreamText)]
     assert len(text_frames) == 1
     assert text_frames[0].chunk == "Summary"

tests/test_schemas_v3.py

@@ -213,7 +213,7 @@ def test_stream_block_timeline():
     frame = WsStreamBlock(
         request_id="r1",
         block_type="timeline",
-        data={"checkpoints": [{"id": "c1", "title": "Launch", "date": 1700000000}]},
+        data={"timelines": [{"id": "c1", "title": "Launch", "date": 1700000000}]},
     )
     assert frame.block_type == "timeline"
 
@@ -270,7 +270,7 @@ def test_floating_domain_tasks():
     assert frame.domain == "tasks"
 
 
-@pytest.mark.parametrize("domain", ["tasks", "checkpoints", "notes", "projects"])
+@pytest.mark.parametrize("domain", ["tasks", "timelines", "notes", "projects"])
 def test_floating_domain_valid_domains(domain: str):
     frame = WsFloatingDomain(request_id="r1", domain=domain)  # type: ignore[arg-type]
     assert frame.domain == domain