fix(static): resolve basedpyright warnings that fail CI

basedpyright's default exit code is non-zero whenever any diagnostics
are reported, so the 8 warnings introduced by the fork-only commits
were failing the Static Analysis job on PR #3 even though there were
no errors.

- src/deriver/queue_manager.py: drop `item.created_at is not None`
  guards. created_at is `Mapped[datetime.datetime]` (non-nullable), so
  the checks were always True and basedpyright flagged them as
  reportUnnecessaryComparison.
- tests/sdk/test_session.py: factor out the shared mock-response body
  into a single helper and give the per-branch closures distinct names.
  This clears reportRedeclaration on `calls` / `fake_post` and lets the
  `# pyright: ignore` comments target the actual warning
  (reportPrivateUsage on `_http` / `_async_http_client`) instead of the
  irrelevant reportAttributeAccessIssue that was flagged as an
  unnecessary ignore.

Author: claude

src/deriver/queue_manager.py

@@ -1161,15 +1161,14 @@ async def mark_queue_items_as_processed(
                 )
                 now_utc = datetime.now(timezone.utc)
                 for item in items:
-                    if item.created_at is not None:
-                        prometheus_metrics.observe_deriver_queue_item_latency(
-                            workspace_name=work_unit.workspace_name,
-                            task_type=work_unit.task_type,
-                            outcome="processed",
-                            latency_seconds=max(
-                                0.0, (now_utc - item.created_at).total_seconds()
-                            ),
-                        )
+                    prometheus_metrics.observe_deriver_queue_item_latency(
+                        workspace_name=work_unit.workspace_name,
+                        task_type=work_unit.task_type,
+                        outcome="processed",
+                        latency_seconds=max(
+                            0.0, (now_utc - item.created_at).total_seconds()
+                        ),
+                    )
 
     async def mark_queue_item_as_errored(
         self, item: QueueItem, work_unit_key: str, error: str
@@ -1201,18 +1200,17 @@ async def mark_queue_item_as_errored(
                     workspace_name=work_unit.workspace_name,
                     task_type=work_unit.task_type,
                 )
-                if item.created_at is not None:
-                    prometheus_metrics.observe_deriver_queue_item_latency(
-                        workspace_name=work_unit.workspace_name,
-                        task_type=work_unit.task_type,
-                        outcome="errored",
-                        latency_seconds=max(
-                            0.0,
-                            (
-                                datetime.now(timezone.utc) - item.created_at
-                            ).total_seconds(),
-                        ),
-                    )
+                prometheus_metrics.observe_deriver_queue_item_latency(
+                    workspace_name=work_unit.workspace_name,
+                    task_type=work_unit.task_type,
+                    outcome="errored",
+                    latency_seconds=max(
+                        0.0,
+                        (
+                            datetime.now(timezone.utc) - item.created_at
+                        ).total_seconds(),
+                    ),
+                )
 
     async def _cleanup_work_unit(
         self,

tests/sdk/test_session.py

@@ -394,38 +394,46 @@ async def test_session_add_messages_chunks_batches_over_limit(
 ):
     honcho_client, client_type = client_fixture
     total_messages = 217
+    calls: list[dict[str, Any]] = []
+
+    def _fake_response(
+        route: str,
+        body: dict[str, Any] | None,
+        query: Any,
+        session_id: str,
+        peer_id: str,
+    ) -> list[dict[str, Any]]:
+        assert body is not None
+        calls.append({"route": route, "body": body, "query": query})
+        return [
+            {
+                "id": f"msg-{len(calls)}-{idx}",
+                "workspace_id": honcho_client.workspace_id,
+                "session_id": session_id,
+                "peer_id": peer_id,
+                "content": item["content"],
+                "metadata": item.get("metadata") or {},
+                "configuration": item.get("configuration") or {},
+                "created_at": "2026-04-02T00:00:00Z",
+                "token_count": 1,
+            }
+            for idx, item in enumerate(body["messages"])
+        ]
 
     if client_type == "async":
         session = await honcho_client.aio.session(id="test-session-add-msg-chunk-async")
         assert isinstance(session, Session)
         user = await honcho_client.aio.peer(id="user-add-msg-chunk-async")
         assert isinstance(user, Peer)
 
-        calls: list[dict[str, Any]] = []
-
-        async def fake_post(
+        async def fake_post_async(
             route: str,
             body: dict[str, Any] | None = None,
             query: Any = None,
         ) -> list[dict[str, Any]]:
-            assert body is not None
-            calls.append({"route": route, "body": body, "query": query})
-            return [
-                {
-                    "id": f"msg-{len(calls)}-{idx}",
-                    "workspace_id": honcho_client.workspace_id,
-                    "session_id": session.id,
-                    "peer_id": user.id,
-                    "content": item["content"],
-                    "metadata": item.get("metadata") or {},
-                    "configuration": item.get("configuration") or {},
-                    "created_at": "2026-04-02T00:00:00Z",
-                    "token_count": 1,
-                }
-                for idx, item in enumerate(body["messages"])
-            ]
+            return _fake_response(route, body, query, session.id, user.id)
 
-        honcho_client._async_http_client.post = AsyncMock(side_effect=fake_post)  # pyright: ignore[reportAttributeAccessIssue]
+        honcho_client._async_http_client.post = AsyncMock(side_effect=fake_post_async)  # pyright: ignore[reportPrivateUsage]
 
         result = await session.aio.add_messages(
             [user.message(f"message {i}") for i in range(total_messages)]
@@ -436,31 +444,14 @@ async def fake_post(
         user = honcho_client.peer(id="user-add-msg-chunk-sync")
         assert isinstance(user, Peer)
 
-        calls: list[dict[str, Any]] = []
-
-        def fake_post(
+        def fake_post_sync(
             route: str,
             body: dict[str, Any] | None = None,
             query: Any = None,
         ) -> list[dict[str, Any]]:
-            assert body is not None
-            calls.append({"route": route, "body": body, "query": query})
-            return [
-                {
-                    "id": f"msg-{len(calls)}-{idx}",
-                    "workspace_id": honcho_client.workspace_id,
-                    "session_id": session.id,
-                    "peer_id": user.id,
-                    "content": item["content"],
-                    "metadata": item.get("metadata") or {},
-                    "configuration": item.get("configuration") or {},
-                    "created_at": "2026-04-02T00:00:00Z",
-                    "token_count": 1,
-                }
-                for idx, item in enumerate(body["messages"])
-            ]
+            return _fake_response(route, body, query, session.id, user.id)
 
-        honcho_client._http.post = Mock(side_effect=fake_post)  # pyright: ignore[reportAttributeAccessIssue]
+        honcho_client._http.post = Mock(side_effect=fake_post_sync)  # pyright: ignore[reportPrivateUsage]
 
         result = session.add_messages(
             [user.message(f"message {i}") for i in range(total_messages)]