Fix/bug detection issues

[markus-lassfolk]

Summary

Closes #

Type of change

• 🐛 Bug fix (non-breaking change that fixes an issue)
• ✨ New feature (non-breaking change that adds functionality)
• 💥 Breaking change (fix or feature that would cause existing functionality to change)
• 🧹 Refactor / code cleanup (no behaviour change)
• 📝 Documentation update
• ⚙️ CI/CD / tooling change

Changes made

Testing

• Added / updated pytest tests
• All tests pass locally (pytest tests/)
• Tested manually against Yarbo hardware (if applicable — describe setup below)

Quality checklist

• ruff lint: Zero errors (ruff check src/ tests/)
• ruff format: No formatting issues (ruff format --check src/ tests/)
• mypy: Zero new type errors (mypy src/yarbo/)
• Tests pass: pytest tests/ — all green
• CHANGELOG.md updated under [Unreleased]
• Docs updated (docstrings, README if API changed)
• No secrets, credentials, IP addresses, or serial numbers in code, comments, or commits
• Follows coding standards in CONTRIBUTING.md

Screenshots / output (optional)

---

Reviewer note: Branch must be up-to-date with develop and all CI checks must pass before merge.

---

Note

Low Risk
The provided diff contains no code changes, so there is effectively no behavioral risk. Only merge/process risk remains (e.g., ensuring this PR is not missing intended commits).

Overview
No source changes are present in the provided diff (+++ /dev/null only), so this PR is effectively a no-op from a code perspective.

^{Written by Cursor Bugbot for commit 8c2df01. This will update automatically on new commits. Configure here.}

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[Copilot]

Pull request overview

This PR expands the python-yarbo client surface with many new typed MQTT command methods (plus corresponding tests), adjusts MQTT connection handling to avoid blocking the event loop, and updates packaging/docs/CI to match the project’s evolving scope.

Changes:

• Add a large set of typed command helpers to YarboLocalClient and delegate them through YarboClient, plus a comprehensive new test suite.
• Make MQTT connect() non-blocking by running paho’s blocking connect in an executor.
• Rework error reporting defaults, packaging metadata, docs, and security/CI workflows (pip-audit + CodeQL).

Reviewed changes

Copilot reviewed 13 out of 13 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
tests/test_typed_commands.py	New test suite covering typed command helpers and delegation behavior.
tests/test_cloud_mqtt.py	Fix env-var isolation for default username test via monkeypatch.
src/yarbo/mqtt.py	Avoid blocking the asyncio loop during MQTT connect.
src/yarbo/local.py	Add many typed command methods and a _request_data_feedback helper.
src/yarbo/error_reporting.py	Change Sentry/GlitchTip initialization behavior, add DSN resolution + scrubbing tweaks.
src/yarbo/client.py	Add delegation wrappers for the new typed local client methods.
src/yarbo/init.py	Update top-level module description text.
pyproject.toml	Bump version/description and move sentry-sdk to an optional extra.
README.md	Adjust positioning text and protocol notes wording.
.github/workflows/security.yml	Change pip-audit invocation to audit from a frozen requirements file.
.github/workflows/codeql.yml	Add CodeQL workflow.
.github/workflows/ci.yml	Simplify gate steps using shell test.
.github/codeql/codeql-config.yml	Add CodeQL query filters and ignore paths.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[cursor]

Cursor Bugbot has reviewed your changes and found 3 potential issues.

Autofix Details

Bugbot Autofix prepared fixes for all 3 issues found in the latest run.

• ✅ Fixed: publish_command delegates to wrong underlying method
  • Changed YarboClient.publish_command to delegate to self._local.publish_command instead of self._local.publish_raw to maintain consistent delegation pattern and correct controller acquisition behavior.
• ✅ Fixed: Private attribute accessed instead of public release_queue
  • Replaced direct access to self._transport._message_queues.remove() with the public self._transport.release_queue() method in _request_data_feedback exception handler.
• ✅ Fixed: Version mismatch between pyproject.toml and __init__.py
  • Updated version in src/yarbo/init.py from 0.1.0 to 0.1.1 to match the version in pyproject.toml.

Preview (8ffd2dc12e)

diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
new file mode 100644
--- /dev/null
+++ b/.github/codeql/codeql-config.yml
@@ -1,0 +1,20 @@
+name: "Yarbo CodeQL Config"
+
+# Disable queries that flag core IoT features as privacy issues
+# GPS coordinates, IP addresses, MAC addresses, and hostnames are
+# fundamental to robot mower discovery and control — not PII leaks.
+query-filters:
+  - exclude:
+      tags contain: security/cwe/cwe-532  # Clear-text logging (we handle this ourselves)
+  - exclude:
+      tags contain: security/cwe/cwe-359  # Privacy violation (GPS, IP, MAC are core features)
+  - exclude:
+      tags contain: security/cwe/cwe-200  # Information exposure (device telemetry is the product)
+  - exclude:
+      id: py/clear-text-logging-sensitive-data
+  - exclude:
+      id: py/clear-text-storage-sensitive-data
+
+paths-ignore:
+  - tests
+  - archive

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -92,7 +92,7 @@
     needs: lint
     if: always() && (needs.lint.result == 'success' || needs.lint.result == 'failure')
     steps:
-      - run: exit ${{ needs.lint.result == 'success' && 0 || 1 }}
+      - run: test '${{ needs.lint.result }}' = success
 
   test-gate:
     name: Test
@@ -100,4 +100,4 @@
     needs: test
     if: always() && (needs.test.result == 'success' || needs.test.result == 'failure')
     steps:
-      - run: exit ${{ needs.test.result == 'success' && 0 || 1 }}
+      - run: test '${{ needs.test.result }}' = success

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -1,0 +1,27 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+permissions:
+  security-events: write
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        language: [python]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          config-file: .github/codeql/codeql-config.yml
+      - uses: github/codeql-action/autobuild@v3
+      - uses: github/codeql-action/analyze@v3

diff --git a/.github/workflows/security.yml b/.github/workflows/security.yml
--- a/.github/workflows/security.yml
+++ b/.github/workflows/security.yml
@@ -32,7 +32,9 @@
         run: pip install ".[dev]"
 
       - name: Run pip-audit
-        run: pip-audit --skip-pkg python-yarbo --strict
+        run: |
+          pip freeze | grep -v "^python-yarbo" > requirements-audit.txt || true
+          pip-audit -r requirements-audit.txt --strict
 
   bandit:
     name: bandit (static analysis)

diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -5,11 +5,11 @@
 [![Python versions](https://img.shields.io/pypi/pyversions/python-yarbo.svg)](https://pypi.org/project/python-yarbo/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-Python library for **local and cloud control** of [Yarbo](https://yarbo.com/) robot
-mowers and snow blowers — built from reverse-engineered protocol knowledge.
+Python library for **local control** of [Yarbo](https://yarbo.com/) robot
+mowers and snow blowers via MQTT.
 
 > **Status**: Alpha (0.1.0) — local MQTT control is functional and confirmed working
-> on hardware. Cloud API is partially functional (JWT auth migration in progress).
+> on hardware.
 
 ## Features
 
@@ -225,8 +225,7 @@
 
 ## Protocol Notes
 
-This library was built from reverse-engineering the Yarbo Flutter app and
-live packet captures. Key protocol facts:
+Key protocol facts for local MQTT communication:
 
 - **MQTT broker**: Local EMQX at `192.168.1.24:1883` or `192.168.1.55:1883`
   (check which IP your robot uses — both have been observed in production)
@@ -260,5 +259,5 @@
 
 ## Disclaimer
 
-This library was built by reverse engineering. It is not affiliated with or endorsed by
+This is a community project. It is not affiliated with or endorsed by
 Yarbo. Use at your own risk. Do not expose your robot's MQTT broker to the internet.

diff --git a/pyproject.toml b/pyproject.toml
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,8 +4,8 @@
 
 [project]
 name = "python-yarbo"
-version = "0.1.0"
-description = "Python library for local and cloud control of Yarbo robot mowers via MQTT"
+version = "0.1.1"
+description = "Python library for local control of Yarbo robot mowers and snow blowers via MQTT"
 readme = "README.md"
 license = { text = "MIT" }
 authors = [{ name = "Markus Lassfolk" }]
@@ -25,10 +25,12 @@
 dependencies = [
     "paho-mqtt>=2.0",
     "aiohttp>=3.9",
-    "sentry-sdk>=2.0",
 ]
 
 [project.optional-dependencies]
+sentry = [
+    "sentry-sdk>=2.0",
+]
 cloud = [
     "cryptography>=42.0",
 ]

diff --git a/src/yarbo/__init__.py b/src/yarbo/__init__.py
--- a/src/yarbo/__init__.py
+++ b/src/yarbo/__init__.py
@@ -1,9 +1,9 @@
 """
-yarbo — Python library for local and cloud control of Yarbo robot mowers.
+yarbo — Python library for local control of Yarbo robot mowers and snow blowers via MQTT.
 
 Yarbo makes autonomous snow blowers and lawn mowers controlled via local MQTT.
-This library was built from reverse-engineering the Yarbo Flutter app and
-probing the protocol with live hardware captures.
+This library provides typed Python methods for controlling Yarbo devices
+over the local network.
 
 Quick start (async)::
 
@@ -45,7 +45,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __author__ = "Markus Lassfolk"
 __license__ = "MIT"
 

diff --git a/src/yarbo/client.py b/src/yarbo/client.py
--- a/src/yarbo/client.py
+++ b/src/yarbo/client.py
@@ -204,6 +204,324 @@
         """Publish an arbitrary MQTT command to the robot."""
         await self._local.publish_raw(cmd, payload)
 
+    async def publish_command(self, cmd: str, payload: dict[str, Any]) -> None:
+        """Alias for :meth:`publish_raw` — publish an arbitrary MQTT command to the robot."""
+        await self._local.publish_command(cmd, payload)
+
+    # -- Robot control --
+
+    async def shutdown(self) -> None:
+        """Power off the robot."""
+        await self._local.shutdown()
+
+    async def restart_container(self) -> None:
+        """Restart the EMQX container on the robot."""
+        await self._local.restart_container()
+
+    async def emergency_stop(self) -> None:
+        """Trigger an emergency stop."""
+        await self._local.emergency_stop()
+
+    async def emergency_unlock(self) -> None:
+        """Clear the emergency stop state."""
+        await self._local.emergency_unlock()
+
+    async def dstop(self) -> None:
+        """Soft-stop the robot (decelerate to halt)."""
+        await self._local.dstop()
+
+    async def resume(self) -> None:
+        """Resume operation after a pause or soft-stop."""
+        await self._local.resume()
+
+    async def cmd_recharge(self) -> None:
+        """Send the robot back to its charging dock."""
+        await self._local.cmd_recharge()
+
+    # -- Lights & sound --
+
+    async def set_head_light(self, enabled: bool) -> None:
+        """Enable or disable the head light."""
+        await self._local.set_head_light(enabled)
+
+    async def set_roof_lights(self, enabled: bool) -> None:
+        """Enable or disable the roof lights."""
+        await self._local.set_roof_lights(enabled)
+
+    async def set_laser(self, enabled: bool) -> None:
+        """Enable or disable the laser."""
+        await self._local.set_laser(enabled)
+
+    async def set_sound(self, volume: int, song_id: int = 0) -> None:
+        """Set the speaker volume (0-100)."""
+        await self._local.set_sound(volume, song_id)
+
+    async def play_song(self, song_id: int) -> None:
+        """Play a sound/song by ID."""
+        await self._local.play_song(song_id)
+
+    # -- Camera & detection --
+
+    async def set_camera(self, enabled: bool) -> None:
+        """Enable or disable the camera."""
+        await self._local.set_camera(enabled)
+
+    async def set_person_detect(self, enabled: bool) -> None:
+        """Enable or disable person detection."""
+        await self._local.set_person_detect(enabled)
+
+    async def set_usb(self, enabled: bool) -> None:
+        """Enable or disable the USB port."""
+        await self._local.set_usb(enabled)
+
+    # -- Plans & scheduling --
+
+    async def start_plan_direct(self, plan_id: int, percent: int = 100) -> None:
+        """Start a work plan by numeric ID (direct command, no response)."""
+        await self._local.start_plan_direct(plan_id, percent)
+
+    async def read_plan(self, plan_id: int, timeout: float = 5.0) -> dict[str, Any]:
+        """Request plan detail and await the data_feedback response."""
+        return await self._local.read_plan(plan_id, timeout)
+
+    async def read_all_plans(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all plan summaries and await the data_feedback response."""
+        return await self._local.read_all_plans(timeout)
+
+    async def delete_plan_direct(self, plan_id: int, confirm: bool = False) -> None:
+        """Delete a plan by numeric ID. Pass confirm=True to proceed (destructive)."""
+        await self._local.delete_plan_direct(plan_id, confirm=confirm)
+
+    async def delete_all_plans(self, confirm: bool = False) -> None:
+        """Delete all stored plans from the robot. Pass confirm=True to proceed (destructive)."""
+        await self._local.delete_all_plans(confirm=confirm)
+
+    async def pause_planning(self) -> None:
+        """Pause the currently running plan (direct command, no response)."""
+        await self._local.pause_planning()
+
+    async def in_plan_action(self, action: str) -> None:
+        """Send an in-plan action command."""
+        await self._local.in_plan_action(action)
+
+    async def read_schedules(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all schedules and await the data_feedback response."""
+        return await self._local.read_schedules(timeout)
+
+    # -- Navigation & maps --
+
+    async def start_waypoint(self, index: int) -> None:
+        """Start navigation to a waypoint by index."""
+        await self._local.start_waypoint(index)
+
+    async def read_recharge_point(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the saved recharge/dock point and await the data_feedback response."""
+        return await self._local.read_recharge_point(timeout)
+
+    async def save_charging_point(self) -> None:
+        """Save the robot's current position as the charging/dock point."""
+        await self._local.save_charging_point()
+
+    async def read_clean_area(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the clean area definition and await the data_feedback response."""
+        return await self._local.read_clean_area(timeout)
+
+    async def get_all_map_backup(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all map backups and await the data_feedback response."""
+        return await self._local.get_all_map_backup(timeout)
+
+    async def save_map_backup(self) -> None:
+        """Save a backup of the current map."""
+        await self._local.save_map_backup()
+
+    # -- WiFi & connectivity --
+
+    async def get_wifi_list(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the list of available WiFi networks and await the data_feedback response."""
+        return await self._local.get_wifi_list(timeout)
+
+    async def get_connected_wifi(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the connected WiFi network name and await the data_feedback response."""
+        return await self._local.get_connected_wifi(timeout)
+
+    async def start_hotspot(self) -> None:
+        """Start the robot's WiFi hotspot."""
+        await self._local.start_hotspot()
+
+    async def get_hub_info(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request hub information and await the data_feedback response."""
+        return await self._local.get_hub_info(timeout)
+
+    # -- Diagnostics --
+
+    async def read_no_charge_period(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request no-charge period configuration and await the data_feedback response."""
+        return await self._local.read_no_charge_period(timeout)
+
+    async def get_battery_cell_temps(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request battery cell temperature data and await the data_feedback response."""
+        return await self._local.get_battery_cell_temps(timeout)
+
+    async def get_motor_temps(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request motor temperature data and await the data_feedback response."""
+        return await self._local.get_motor_temps(timeout)
+
+    async def get_body_current(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request body current telemetry and await the data_feedback response."""
+        return await self._local.get_body_current(timeout)
+
+    async def get_head_current(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request head current telemetry and await the data_feedback response."""
+        return await self._local.get_head_current(timeout)
+
+    async def get_speed(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request current speed telemetry and await the data_feedback response."""
+        return await self._local.get_speed(timeout)
+
+    async def get_odometer(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request odometer data and await the data_feedback response."""
+        return await self._local.get_odometer(timeout)
+
+    async def get_product_code(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the product code and await the data_feedback response."""
+        return await self._local.get_product_code(timeout)
+
+    # -- Blade / mowing configuration --
+
+    async def set_blade_height(self, height: int) -> None:
+        """Set the blade cutting height."""
+        await self._local.set_blade_height(height)
+
+    async def set_blade_speed(self, speed: int) -> None:
+        """Set the blade rotation speed."""
+        await self._local.set_blade_speed(speed)
+
+    async def set_charge_limit(self, min_pct: int, max_pct: int) -> None:
+        """Set battery charge limits."""
+        await self._local.set_charge_limit(min_pct, max_pct)
+
+    async def set_turn_type(self, turn_type: int) -> None:
+        """Set the turning behaviour type."""
+        await self._local.set_turn_type(turn_type)
+
+    # -- Snow blower accessories --
+
+    async def push_snow_dir(self, direction: int) -> None:
+        """Set the snow push direction."""
+        await self._local.push_snow_dir(direction)
+
+    async def set_chute_steering_work(self, angle: int) -> None:
+        """Set the chute steering angle during work."""
+        await self._local.set_chute_steering_work(angle)
+
+    async def set_roller_speed(self, speed: int) -> None:
+        """Set the roller/blower speed."""
+        await self._local.set_roller_speed(speed)
+
+    # -- Motor & mechanical --
+
+    async def set_motor_protect(self, state: int) -> None:
+        """Enable or disable motor protection mode."""
+        await self._local.set_motor_protect(state)
+
+    async def set_trimmer(self, state: int) -> None:
+        """Enable or disable the trimmer."""
+        await self._local.set_trimmer(state)
+
+    # -- Blowing / edge / smart features --
+
+    async def set_edge_blowing(self, state: int) -> None:
+        """Enable or disable edge blowing."""
+        await self._local.set_edge_blowing(state)
+
+    async def set_smart_blowing(self, state: int) -> None:
+        """Enable or disable smart blowing."""
+        await self._local.set_smart_blowing(state)
+
+    async def set_heating_film(self, state: int) -> None:
+        """Enable or disable heating film (anti-ice)."""
+        await self._local.set_heating_film(state)
+
+    async def set_module_lock(self, state: int) -> None:
+        """Lock or unlock an accessory module."""
+        await self._local.set_module_lock(state)
+
+    # -- Autonomous modes --
+
+    async def set_follow_mode(self, state: int) -> None:
+        """Enable or disable follow mode."""
+        await self._local.set_follow_mode(state)
+
+    async def set_draw_mode(self, state: int) -> None:
+        """Enable or disable draw/mapping mode."""
+        await self._local.set_draw_mode(state)
+
+    # -- OTA / firmware updates --
+
+    async def set_auto_update(self, state: int) -> None:
+        """Enable or disable automatic firmware (Greengrass) updates."""
+        await self._local.set_auto_update(state)
+
+    async def set_camera_ota(self, state: int) -> None:
+        """Enable or disable IP camera OTA updates."""
+        await self._local.set_camera_ota(state)
+
+    # -- Vision / recording --
+
+    async def set_smart_vision(self, state: int) -> None:
+        """Enable or disable smart vision processing."""
+        await self._local.set_smart_vision(state)
+
+    async def set_video_record(self, state: int) -> None:
+        """Enable or disable video recording."""
+        await self._local.set_video_record(state)
+
+    # -- Safety / fencing --
+
+    async def set_child_lock(self, state: int) -> None:
+        """Enable or disable the child lock."""
+        await self._local.set_child_lock(state)
+
+    async def set_geo_fence(self, state: int) -> None:
+        """Enable or disable geo-fencing."""
+        await self._local.set_geo_fence(state)
+
+    async def set_elec_fence(self, state: int) -> None:
+        """Enable or disable the electric fence."""
+        await self._local.set_elec_fence(state)
+
+    async def set_ngz_edge(self, state: int) -> None:
+        """Enable or disable NGZ edge enforcement."""
+        await self._local.set_ngz_edge(state)
+
+    # -- Manual drive extras --
+
+    async def set_velocity_manual(self, linear: float, angular: float) -> None:
+        """Send a velocity command in manual drive mode."""
+        await self._local.set_velocity_manual(linear, angular)
+
+    async def set_sound_param(self, volume: int, enabled: int) -> None:
+        """Set sound volume and enable/disable audio output."""
+        await self._local.set_sound_param(volume, enabled)
+
+    # -- Map management (destructive) --
+
+    async def erase_map(self, confirm: bool = False) -> None:
+        """Erase the robot's stored map. Pass confirm=True to proceed (destructive)."""
+        await self._local.erase_map(confirm=confirm)
+
+    async def map_recovery(self, map_id: str, confirm: bool = False) -> None:
+        """Restore a map from backup. Pass confirm=True to proceed (destructive)."""
+        await self._local.map_recovery(map_id, confirm=confirm)
+
+    async def save_current_map(self) -> None:
+        """Save the robot's current map state."""
+        await self._local.save_current_map()
+
+    async def save_map_backup_list(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Save map backup and retrieve all map backup names and IDs."""
+        return await self._local.save_map_backup_list(timeout)
+
     # ------------------------------------------------------------------
     # Plan management (delegated to YarboLocalClient)
     # ------------------------------------------------------------------

diff --git a/src/yarbo/error_reporting.py b/src/yarbo/error_reporting.py
--- a/src/yarbo/error_reporting.py
+++ b/src/yarbo/error_reporting.py
@@ -1,83 +1,114 @@
-"""GlitchTip/Sentry error reporting for python-yarbo."""
+"""GlitchTip/Sentry error reporting for the python-yarbo library."""
 
+from __future__ import annotations
+
 import logging
+import os
 import re
 
-logger = logging.getLogger(__name__)
+_LOGGER = logging.getLogger(__name__)
 
-# Sensitive-key scrubbing helpers — compiled once at import time.
-_SCRUB_KEY_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential", "key")
-_SCRUB_MSG_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential")
-_SCRUB_KEY_PATTERN = re.compile(r"(?:_|api|access|auth|private)key", re.IGNORECASE)
+# Default DSN for the python-yarbo GlitchTip project.
+# Opt-out: set YARBO_SENTRY_DSN="" to disable error reporting.
+_DEFAULT_DSN = "https://c690590f8f664d609f6abe4cb0392d53@villapolly.duckdns.org/2"
 
 
 def init_error_reporting(
     dsn: str | None = None,
     environment: str = "production",
     enabled: bool = True,
+    tags: dict[str, str] | None = None,
 ) -> None:
-    """Initialize Sentry/GlitchTip error reporting.
+    """Initialize Sentry/GlitchTip error reporting for python-yarbo.
 
-    Opt-in: enable by providing a DSN via argument or environment variables.
-    To disable explicitly, pass enabled=False or set YARBO_SENTRY_DSN="".
+    Enabled by default during the beta — errors are reported to help identify
+    and fix bugs. No PII is collected; credentials are scrubbed before sending.
 
+    To disable, set the YARBO_SENTRY_DSN environment variable to an empty string.
+    To use a custom DSN, set YARBO_SENTRY_DSN to your project DSN.
+
     Args:
-        dsn: Sentry DSN. If omitted, falls back to the ``YARBO_SENTRY_DSN`` or
-             ``SENTRY_DSN`` environment variables.  No compiled-in default is
-             provided; set the env var explicitly.  Pass ``enabled=False`` or
-             set ``YARBO_SENTRY_DSN=""`` to fully disable reporting.
+        dsn: Sentry DSN override. If None, falls back to YARBO_SENTRY_DSN env var,
+             then to the built-in default DSN.
         environment: Environment tag (production/development/testing).
         enabled: Master switch. If False, no SDK initialization occurs.
+        tags: Optional extra tags (e.g. robot_serial, library_version).
     """
     if not enabled:
         return
 
-    import os  # noqa: PLC0415
-
-    # Check for explicit disable via empty env var
+    # Resolve DSN: explicit arg > YARBO_SENTRY_DSN env var > built-in default
     env_dsn = os.environ.get("YARBO_SENTRY_DSN")
     if env_dsn is not None and env_dsn == "":
-        return  # Explicitly disabled
+        _LOGGER.debug("Error reporting explicitly disabled via YARBO_SENTRY_DSN=\"\"")
+        return
+    effective_dsn = dsn or env_dsn or _DEFAULT_DSN
 
-    dsn = dsn or env_dsn or os.environ.get("SENTRY_DSN")
-
-    if not dsn:
+    if not effective_dsn:
         return
 
     try:
         import sentry_sdk  # noqa: PLC0415
 
         sentry_sdk.init(
-            dsn=dsn,
+            dsn=effective_dsn,
             environment=environment,
             traces_sample_rate=0.1,
             send_default_pii=False,
-            before_send=_scrub_event,  # type: ignore[arg-type, unused-ignore]
+            before_send=_scrub_event,
         )
-        logger.debug("Error reporting initialized (dsn=%s...)", dsn[:30])
+
+        if tags:
+            for key, value in tags.items():
+                sentry_sdk.set_tag(key, value)
+
+        _LOGGER.debug("Error reporting initialized (dsn=%s...)", effective_dsn[:30])
     except ImportError:
-        logger.debug("sentry-sdk not installed; error reporting disabled")
+        _LOGGER.debug("sentry-sdk not installed; error reporting disabled")
     except Exception as exc:  # noqa: BLE001
-        logger.warning("Failed to initialize error reporting: %s", exc)
+        _LOGGER.warning("Failed to initialize error reporting: %s", exc)
 
 
+# Non-sensitive field names that contain "_key" but must not be redacted.
+_KEY_ALLOWLIST: frozenset[str] = frozenset({"entity_key"})
+
+# Pattern to detect key-like strings in breadcrumb messages (e.g., "apikey", "access_key")
+_SCRUB_KEY_PATTERN = re.compile(r"(?:_|api|access|auth|private)key", re.IGNORECASE)
+
+
+def _is_sensitive_key(key_lower: str) -> bool:
+    """Check if a key name looks sensitive and should be redacted."""
+    if any(s in key_lower for s in ("password", "token", "secret", "credential")):
+        return True
+    if key_lower in _KEY_ALLOWLIST:
+        return False
+    return (
+        key_lower == "key"
+        or "_key" in key_lower
+        or key_lower.startswith("key_")
+        or key_lower.endswith("key")
+    )
+
+
 def _scrub_event(event: dict, hint: dict) -> dict:  # type: ignore[type-arg]
     """Remove sensitive data before sending."""
     if "extra" in event:
         for key in list(event["extra"]):
-            if any(s in key.lower() for s in _SCRUB_KEY_KEYWORDS):
+            if _is_sensitive_key(key.lower()):
                 event["extra"][key] = "[REDACTED]"
 
     if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
         for breadcrumb in event["breadcrumbs"]["values"]:
             if "message" in breadcrumb:
                 msg = str(breadcrumb["message"])
-                sensitive = any(s in msg.lower() for s in _SCRUB_MSG_KEYWORDS)
+                msg_lower = msg.lower()
+                keywords = ("password", "token", "secret", "credential")
+                sensitive = any(s in msg_lower for s in keywords)
                 if sensitive or _SCRUB_KEY_PATTERN.search(msg):
                     breadcrumb["message"] = "[REDACTED]"
             if "data" in breadcrumb and isinstance(breadcrumb["data"], dict):
                 for key in list(breadcrumb["data"]):
-                    if any(s in key.lower() for s in _SCRUB_KEY_KEYWORDS):
+                    if _is_sensitive_key(key.lower()):
                         breadcrumb["data"][key] = "[REDACTED]"
 
     return event

diff --git a/src/yarbo/local.py b/src/yarbo/local.py
--- a/src/yarbo/local.py
+++ b/src/yarbo/local.py
@@ -33,6 +33,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 from datetime import UTC, datetime
 import logging
 import time
@@ -752,9 +753,490 @@
         return await self._publish_and_wait("save_plan", payload)
 
     # ------------------------------------------------------------------
+    # Robot control
+    # ------------------------------------------------------------------
+
+    async def shutdown(self) -> None:
+        """Power off the robot."""
+        await self._ensure_controller()
+        await self._transport.publish("shutdown", {})
+
+    async def restart_container(self) -> None:
+        """Restart the EMQX container on the robot."""
+        await self._ensure_controller()
+        await self._transport.publish("restart_container", {})
+
+    async def emergency_stop(self) -> None:
+        """Trigger an emergency stop."""
+        await self._ensure_controller()
+        await self._transport.publish("emergency_stop_active", {})
+
+    async def emergency_unlock(self) -> None:
+        """Clear the emergency stop state."""
+        await self._ensure_controller()
+        await self._transport.publish("emergency_unlock", {})
+
+    async def dstop(self) -> None:
+        """Soft-stop the robot (decelerate to halt)."""
+        await self._ensure_controller()
+        await self._transport.publish("dstop", {})
+
+    async def resume(self) -> None:
+        """Resume operation after a pause or soft-stop."""
+        await self._ensure_controller()
+        await self._transport.publish("resume", {})
+
+    async def cmd_recharge(self) -> None:
+        """Send the robot back to its charging dock."""
+        await self._ensure_controller()
+        await self._transport.publish("cmd_recharge", {})
+
+    # ------------------------------------------------------------------
+    # Lights & sound
+    # ------------------------------------------------------------------
+
+    async def set_head_light(self, enabled: bool) -> None:
+        """
+        Enable or disable the head light.
+
+        Args:
+            enabled: True to turn on, False to turn off.
+        """
+        await self._ensure_controller()
+        await self._transport.publish("head_light", {"state": 1 if enabled else 0})
+
+    async def set_roof_lights(self, enabled: bool) -> None:
+        """
+        Enable or disable the roof lights.
+
+        Args:
+            enabled: True to turn on, False to turn off.
+        """
+        await self._ensure_controller()
+        await self._transport.publish("roof_lights_enable", {"enable": 1 if enabled else 0})
+
+    async def set_laser(self, enabled: bool) -> None:
+        """
+        Enable or disable the laser.
+
+        Args:
+            enabled: True to enable, False to disable.
+        """
+        await self._ensure_controller()
+        await self._transport.publish("laser_toggle", {"enabled": enabled})
+
+    async def set_sound(self, volume: int, song_id: int = 0) -> None:
+        """
+        Set the speaker volume.
+
+        Args:
+            volume:  Volume level (0-100).
+            song_id: Song identifier (reserved, default 0).
+        """
+        await self._ensure_controller()
+        await self._transport.publish("set_sound_param", {"vol": volume, "songId": song_id})
+
+    async def play_song(self, song_id: int) -> None:
+        """
+        Play a sound/song by ID.
+
+        Args:
+            song_id: Identifier of the song to play.
+        """
+        await self._ensure_controller()
+        await self._transport.publish("song_cmd", {"songId": song_id})
+
+    # ------------------------------------------------------------------
+    # Camera & detection
+    # ------------------------------------------------------------------
+
+    async def set_camera(self, enabled: bool) -> None:
+        """
+        Enable or disable the camera.
+
+        Args:
+            enabled: True to enable, False to disable.
+        """
+        await self._ensure_controller()
+        await self._transport.publish("camera_toggle", {"enabled": enabled})
+
+    async def set_person_detect(self, enabled: bool) -> None:
+        """
+        Enable or disable person detection.
+
+        Args:
+            enabled: True to enable, False to disable.
+        """
+        await self._ensure_controller()
+        await self._transport.publish("set_person_detect", {"enable": 1 if enabled else 0})
+
+    async def set_usb(self, enabled: bool) -> None:
+        """
+        Enable or disable the USB port.
+
+        Args:
+            enabled: True to enable, False to disable.
+        """
+        await self._ensure_controller()
... diff truncated: showing 800 of 2215 lines

[cursor]

Cursor Bugbot has reviewed your changes and found 4 potential issues.

Autofix Details

Bugbot Autofix prepared fixes for all 4 issues found in the latest run.

• ✅ Fixed: Duplicate _DEFAULT_DSN — first assignment is dead code
  • Removed the first duplicate assignment to _DEFAULT_DSN, keeping only the glitchtip.lassfolk.cc URL.
• ✅ Fixed: DSN resolution ignores SENTRY_DSN environment variable
  • Added os.environ.get('SENTRY_DSN') to the effective_dsn resolution chain and removed the unused dsn variable.
• ✅ Fixed: Duplicate methods set_roller and set_roller_speed are identical
  • Changed set_roller_speed to delegate to set_roller, eliminating code duplication while maintaining the API.
• ✅ Fixed: CLI passes removed constructor parameters, causing TypeError
  • Removed mqtt_log_path, debug, debug_raw, and mqtt_capture_max parameters from all YarboLocalClient constructor calls and disabled the get_captured_mqtt() call.

Preview (ce8c53cfb0)

diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
new file mode 100644
--- /dev/null
+++ b/.github/codeql/codeql-config.yml
@@ -1,0 +1,20 @@
+name: "Yarbo CodeQL Config"
+
+# Disable queries that flag core IoT features as privacy issues
+# GPS coordinates, IP addresses, MAC addresses, and hostnames are
+# fundamental to robot mower discovery and control — not PII leaks.
+query-filters:
+  - exclude:
+      tags contain: security/cwe/cwe-532  # Clear-text logging (we handle this ourselves)
+  - exclude:
+      tags contain: security/cwe/cwe-359  # Privacy violation (GPS, IP, MAC are core features)
+  - exclude:
+      tags contain: security/cwe/cwe-200  # Information exposure (device telemetry is the product)
+  - exclude:
+      id: py/clear-text-logging-sensitive-data
+  - exclude:
+      id: py/clear-text-storage-sensitive-data
+
+paths-ignore:
+  - tests
+  - archive

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -1,0 +1,27 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+permissions:
+  security-events: write
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        language: [python]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          config-file: .github/codeql/codeql-config.yml
+      - uses: github/codeql-action/autobuild@v3
+      - uses: github/codeql-action/analyze@v3

diff --git a/pyproject.toml b/pyproject.toml
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,10 +25,12 @@
 dependencies = [
     "paho-mqtt>=2.0",
     "aiohttp>=3.9",
-    "sentry-sdk>=2.0",
 ]
 
 [project.optional-dependencies]
+sentry = [
+    "sentry-sdk>=2.0",
+]
 cloud = [
     "cryptography>=42.0",
 ]

diff --git a/src/yarbo/__init__.py b/src/yarbo/__init__.py
--- a/src/yarbo/__init__.py
+++ b/src/yarbo/__init__.py
@@ -1,5 +1,5 @@
 """
-yarbo — Python library for local and cloud control of Yarbo robot mowers.
+yarbo — Python library for local control of Yarbo robot mowers and snow blowers via MQTT.
 
 Yarbo makes autonomous snow blowers and lawn mowers controlled via local MQTT.
 This is a community-developed library for the Yarbo protocol, built through
@@ -58,7 +58,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __author__ = "Markus Lassfolk"
 __license__ = "MIT"
 

diff --git a/src/yarbo/_cli.py b/src/yarbo/_cli.py
--- a/src/yarbo/_cli.py
+++ b/src/yarbo/_cli.py
@@ -205,8 +205,8 @@
 
 def _maybe_report_mqtt(args: argparse.Namespace, client: YarboLocalClient) -> None:
     """If --report-mqtt was set, send captured MQTT dump to GlitchTip."""
-    if getattr(args, "report_mqtt", False):
-        report_mqtt_dump_to_glitchtip(client.get_captured_mqtt())
+    # MQTT capture functionality has been removed from YarboLocalClient
+    pass
 
 
 async def _with_client(
@@ -218,10 +218,6 @@
             broker=args.broker,
             sn=args.serial,
             port=getattr(args, "port", 1883),
-            mqtt_log_path=getattr(args, "log_mqtt", None),
-            debug=getattr(args, "debug", False),
-            debug_raw=getattr(args, "debug_raw", False),
-            mqtt_capture_max=_mqtt_capture_max(args),
         )
         await client.connect()
         try:
@@ -248,10 +244,6 @@
                 broker=ep.ip,
                 port=ep.port,
                 sn=ep.sn,
-                mqtt_log_path=getattr(args, "log_mqtt", None),
-                debug=getattr(args, "debug", False),
-                debug_raw=getattr(args, "debug_raw", False),
-                mqtt_capture_max=_mqtt_capture_max(args),
             )
             await client.connect()
         except (YarboError, OSError, TimeoutError) as e:

diff --git a/src/yarbo/client.py b/src/yarbo/client.py
--- a/src/yarbo/client.py
+++ b/src/yarbo/client.py
@@ -204,6 +204,300 @@
         """Publish an arbitrary MQTT command to the robot."""
         await self._local.publish_raw(cmd, payload)
 
+    async def publish_command(self, cmd: str, payload: dict[str, Any]) -> None:
+        """Alias for :meth:`publish_raw` — publish an arbitrary MQTT command to the robot."""
+        await self._local.publish_command(cmd, payload)
+
+    # -- Robot control --
+
+    async def shutdown(self) -> None:
+        """Power off the robot."""
+        await self._local.shutdown()
+
+    async def restart_container(self) -> None:
+        """Restart the EMQX container on the robot."""
+        await self._local.restart_container()
+
+    async def emergency_stop(self) -> None:
+        """Trigger an emergency stop."""
+        await self._local.emergency_stop()
+
+    async def emergency_unlock(self) -> None:
+        """Clear the emergency stop state."""
+        await self._local.emergency_unlock()
+
+    async def dstop(self) -> None:
+        """Soft-stop the robot (decelerate to halt)."""
+        await self._local.dstop()
+
+    async def resume(self) -> None:
+        """Resume operation after a pause or soft-stop."""
+        await self._local.resume()
+
+    async def cmd_recharge(self) -> None:
+        """Send the robot back to its charging dock."""
+        await self._local.cmd_recharge()
+
+    # -- Lights & sound --
+
+    async def set_head_light(self, enabled: bool) -> None:
+        """Enable or disable the head light."""
+        await self._local.set_head_light(enabled)
+
+    async def set_roof_lights(self, enabled: bool) -> None:
+        """Enable or disable the roof lights."""
+        await self._local.set_roof_lights(enabled)
+
+    async def set_laser(self, enabled: bool) -> None:
+        """Enable or disable the laser."""
+        await self._local.set_laser(enabled)
+
+    async def set_sound(self, volume: int, song_id: int = 0) -> None:
+        """Set the speaker volume (0-100)."""
+        await self._local.set_sound(volume, song_id)
+
+    async def play_song(self, song_id: int) -> None:
+        """Play a sound/song by ID."""
+        await self._local.play_song(song_id)
+
+    # -- Camera & detection --
+
+    async def set_camera(self, enabled: bool) -> None:
+        """Enable or disable the camera."""
+        await self._local.set_camera(enabled)
+
+    async def set_person_detect(self, enabled: bool) -> None:
+        """Enable or disable person detection."""
+        await self._local.set_person_detect(enabled)
+
+    async def set_usb(self, enabled: bool) -> None:
+        """Enable or disable the USB port."""
+        await self._local.set_usb(enabled)
+
+    # -- Plans & scheduling --
+
+    async def start_plan_direct(self, plan_id: int, percent: int = 100) -> None:
+        """Start a work plan by numeric ID (direct command, no response)."""
+        await self._local.start_plan_direct(plan_id, percent)
+
+    async def read_plan(self, plan_id: int, timeout: float = 5.0) -> dict[str, Any]:
+        """Request plan detail and await the data_feedback response."""
+        return await self._local.read_plan(plan_id, timeout)
+
+    async def read_all_plans(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all plan summaries and await the data_feedback response."""
+        return await self._local.read_all_plans(timeout)
+
+    async def delete_plan_direct(self, plan_id: int, confirm: bool = False) -> None:
+        """Delete a plan by numeric ID. Pass confirm=True to proceed (destructive)."""
+        await self._local.delete_plan_direct(plan_id, confirm=confirm)
+
+    async def delete_all_plans(self, confirm: bool = False) -> None:
+        """Delete all stored plans from the robot. Pass confirm=True to proceed (destructive)."""
+        await self._local.delete_all_plans(confirm=confirm)
+
+    async def pause_planning(self) -> None:
+        """Pause the currently running plan (direct command, no response)."""
+        await self._local.pause_planning()
+
+    async def in_plan_action(self, action: str) -> None:
+        """Send an in-plan action command."""
+        await self._local.in_plan_action(action)
+
+    async def read_schedules(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all schedules and await the data_feedback response."""
+        return await self._local.read_schedules(timeout)
+
+    # -- Navigation & maps --
+
+    async def start_waypoint(self, index: int) -> None:
+        """Start navigation to a waypoint by index."""
+        await self._local.start_waypoint(index)
+
+    async def read_recharge_point(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the saved recharge/dock point and await the data_feedback response."""
+        return await self._local.read_recharge_point(timeout)
+
+    async def save_charging_point(self) -> None:
+        """Save the robot's current position as the charging/dock point."""
+        await self._local.save_charging_point()
+
+    async def read_clean_area(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the clean area definition and await the data_feedback response."""
+        return await self._local.read_clean_area(timeout)
+
+    async def get_all_map_backup(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all map backups and await the data_feedback response."""
+        return await self._local.get_all_map_backup(timeout)
+
+    async def save_map_backup(self) -> None:
+        """Save a backup of the current map."""
+        await self._local.save_map_backup()
+
+    # -- WiFi & connectivity --
+
+    async def get_wifi_list(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the list of available WiFi networks and await the data_feedback response."""
+        return await self._local.get_wifi_list(timeout)
+
+    async def get_connected_wifi(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the connected WiFi network name and await the data_feedback response."""
+        return await self._local.get_connected_wifi(timeout)
+
+    async def start_hotspot(self) -> None:
+        """Start the robot's WiFi hotspot."""
+        await self._local.start_hotspot()
+
+    async def get_hub_info(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request hub information and await the data_feedback response."""
+        return await self._local.get_hub_info(timeout)
+
+    # -- Diagnostics --
+
+    async def read_no_charge_period(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request no-charge period configuration and await the data_feedback response."""
+        return await self._local.read_no_charge_period(timeout)
+
+    async def get_battery_cell_temps(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request battery cell temperature data and await the data_feedback response."""
+        return await self._local.get_battery_cell_temps(timeout)
+
+    async def get_motor_temps(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request motor temperature data and await the data_feedback response."""
+        return await self._local.get_motor_temps(timeout)
+
+    async def get_body_current(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request body current telemetry and await the data_feedback response."""
+        return await self._local.get_body_current(timeout)
+
+    async def get_head_current(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request head current telemetry and await the data_feedback response."""
+        return await self._local.get_head_current(timeout)
+
+    async def get_speed(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request current speed telemetry and await the data_feedback response."""
+        return await self._local.get_speed(timeout)
+
+    async def get_odometer(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request odometer data and await the data_feedback response."""
+        return await self._local.get_odometer(timeout)
+
+    async def get_product_code(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the product code and await the data_feedback response."""
+        return await self._local.get_product_code(timeout)
+
+    async def set_charge_limit(self, min_pct: int, max_pct: int) -> None:
+        """Set battery charge limits."""
+        await self._local.set_charge_limit(min_pct, max_pct)
+
+    async def set_turn_type(self, turn_type: int) -> None:
+        """Set the turning behaviour type."""
+        await self._local.set_turn_type(turn_type)
+
+    # -- Motor & mechanical --
+
+    async def set_motor_protect(self, state: int) -> None:
+        """Enable or disable motor protection mode."""
+        await self._local.set_motor_protect(state)
+
+    async def set_trimmer(self, state: int) -> None:
+        """Enable or disable the trimmer."""
+        await self._local.set_trimmer(state)
+
+    # -- Blowing / edge / smart features --
+
+    async def set_edge_blowing(self, state: int) -> None:
+        """Enable or disable edge blowing."""
+        await self._local.set_edge_blowing(state)
+
+    async def set_smart_blowing(self, state: int) -> None:
+        """Enable or disable smart blowing."""
+        await self._local.set_smart_blowing(state)
+
+    async def set_heating_film(self, state: int) -> None:
+        """Enable or disable heating film (anti-ice)."""
+        await self._local.set_heating_film(state)
+
+    async def set_module_lock(self, state: int) -> None:
+        """Lock or unlock an accessory module."""
+        await self._local.set_module_lock(state)
+
+    # -- Autonomous modes --
+
+    async def set_follow_mode(self, state: int) -> None:
+        """Enable or disable follow mode."""
+        await self._local.set_follow_mode(state)
+
+    async def set_draw_mode(self, state: int) -> None:
+        """Enable or disable draw/mapping mode."""
+        await self._local.set_draw_mode(state)
+
+    # -- OTA / firmware updates --
+
+    async def set_auto_update(self, state: int) -> None:
+        """Enable or disable automatic firmware (Greengrass) updates."""
+        await self._local.set_auto_update(state)
+
+    async def set_camera_ota(self, state: int) -> None:
+        """Enable or disable IP camera OTA updates."""
+        await self._local.set_camera_ota(state)
+
+    # -- Vision / recording --
+
+    async def set_smart_vision(self, state: int) -> None:
+        """Enable or disable smart vision processing."""
+        await self._local.set_smart_vision(state)
+
+    async def set_video_record(self, state: int) -> None:
+        """Enable or disable video recording."""
+        await self._local.set_video_record(state)
+
+    # -- Safety / fencing --
+
+    async def set_child_lock(self, state: int) -> None:
+        """Enable or disable the child lock."""
+        await self._local.set_child_lock(state)
+
+    async def set_geo_fence(self, state: int) -> None:
+        """Enable or disable geo-fencing."""
+        await self._local.set_geo_fence(state)
+
+    async def set_elec_fence(self, state: int) -> None:
+        """Enable or disable the electric fence."""
+        await self._local.set_elec_fence(state)
+
+    async def set_ngz_edge(self, state: int) -> None:
+        """Enable or disable NGZ edge enforcement."""
+        await self._local.set_ngz_edge(state)
+
+    # -- Manual drive extras --
+
+    async def set_velocity_manual(self, linear: float, angular: float) -> None:
+        """Send a velocity command in manual drive mode."""
+        await self._local.set_velocity_manual(linear, angular)
+
+    async def set_sound_param(self, volume: int, enabled: int) -> None:
+        """Set sound volume and enable/disable audio output."""
+        await self._local.set_sound_param(volume, enabled)
+
+    # -- Map management (destructive) --
+
+    async def erase_map(self, confirm: bool = False) -> None:
+        """Erase the robot's stored map. Pass confirm=True to proceed (destructive)."""
+        await self._local.erase_map(confirm=confirm)
+
+    async def map_recovery(self, map_id: str, confirm: bool = False) -> None:
+        """Restore a map from backup. Pass confirm=True to proceed (destructive)."""
+        await self._local.map_recovery(map_id, confirm=confirm)
+
+    async def save_current_map(self) -> None:
+        """Save the robot's current map state."""
+        await self._local.save_current_map()
+
+    async def save_map_backup_list(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Save map backup and retrieve all map backup names and IDs."""
+        return await self._local.save_map_backup_list(timeout)
+
     # ------------------------------------------------------------------
     # Plan management (delegated to YarboLocalClient)
     # ------------------------------------------------------------------

diff --git a/src/yarbo/error_reporting.py b/src/yarbo/error_reporting.py
--- a/src/yarbo/error_reporting.py
+++ b/src/yarbo/error_reporting.py
@@ -8,16 +8,12 @@
 
 import json
 import logging
+import os
 import re
 from typing import Any
 
-logger = logging.getLogger(__name__)
+_LOGGER = logging.getLogger(__name__)
 
-# Sensitive-key scrubbing helpers — compiled once at import time.
-_SCRUB_KEY_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential", "key")
-_SCRUB_MSG_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential")
-_SCRUB_KEY_PATTERN = re.compile(r"(?:_|api|access|auth|private)key", re.IGNORECASE)
-
 # Default DSN for the python-yarbo GlitchTip project.
 # Enabled by default during beta to help find issues.
 # Opt-out: set YARBO_SENTRY_DSN="" or pass enabled=False.
@@ -28,8 +24,9 @@
     dsn: str | None = None,
     environment: str = "production",
     enabled: bool = True,
+    tags: dict[str, str] | None = None,
 ) -> None:
-    """Initialize Sentry/GlitchTip error reporting.
+    """Initialize Sentry/GlitchTip error reporting for python-yarbo.
 
     Enabled by default during beta with a built-in DSN. No PII is collected;
     credentials and sensitive keys are scrubbed before sending.
@@ -41,56 +38,85 @@
              ``SENTRY_DSN`` environment variables, then the built-in default.
         environment: Environment tag (production/development/testing).
         enabled: Master switch. If False, no SDK initialization occurs.
+        tags: Optional extra tags (e.g. robot_serial, library_version).
     """
     if not enabled:
         return
 
-    import os  # noqa: PLC0415
-
-    # Check for explicit disable via empty env var
+    # Resolve DSN: explicit arg > YARBO_SENTRY_DSN env var > SENTRY_DSN env var > built-in default
     env_dsn = os.environ.get("YARBO_SENTRY_DSN")
     if env_dsn is not None and env_dsn == "":
-        return  # Explicitly disabled
+        _LOGGER.debug('Error reporting explicitly disabled via YARBO_SENTRY_DSN=""')
+        return
+    effective_dsn = dsn or env_dsn or os.environ.get("SENTRY_DSN") or _DEFAULT_DSN
 
-    dsn = dsn or env_dsn or os.environ.get("SENTRY_DSN") or _DEFAULT_DSN
-
-    if not dsn:
+    if not effective_dsn:
         return
 
     try:
         import sentry_sdk  # noqa: PLC0415
 
         sentry_sdk.init(
-            dsn=dsn,
+            dsn=effective_dsn,
             environment=environment,
             traces_sample_rate=0.1,
             send_default_pii=False,
-            before_send=_scrub_event,  # type: ignore[arg-type, unused-ignore]
+            before_send=_scrub_event,
         )
-        logger.debug("Error reporting initialized (dsn=%s...)", dsn[:30])
+
+        if tags:
+            for key, value in tags.items():
+                sentry_sdk.set_tag(key, value)
+
+        _LOGGER.debug("Error reporting initialized (dsn=%s...)", effective_dsn[:30])
     except ImportError:
-        logger.debug("sentry-sdk not installed; error reporting disabled")
+        _LOGGER.debug("sentry-sdk not installed; error reporting disabled")
     except Exception as exc:  # noqa: BLE001
-        logger.warning("Failed to initialize error reporting: %s", exc)
+        _LOGGER.warning("Failed to initialize error reporting: %s", exc)
 
 
+# Non-sensitive field names that contain "_key" but must not be redacted.
+_KEY_ALLOWLIST: frozenset[str] = frozenset({"entity_key"})
+
+# Pattern to detect key-like strings in breadcrumb messages (e.g., "apikey", "access_key")
+_SCRUB_KEY_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential", "key")
+_SCRUB_MSG_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential")
+_SCRUB_KEY_PATTERN = re.compile(r"(?:_|api|access|auth|private)key", re.IGNORECASE)
+
+
+def _is_sensitive_key(key_lower: str) -> bool:
+    """Check if a key name looks sensitive and should be redacted."""
+    if any(s in key_lower for s in ("password", "token", "secret", "credential")):
+        return True
+    if key_lower in _KEY_ALLOWLIST:
+        return False
+    return (
+        key_lower == "key"
+        or "_key" in key_lower
+        or key_lower.startswith("key_")
+        or key_lower.endswith("key")
+    )
+
+
 def _scrub_event(event: dict, hint: dict) -> dict:  # type: ignore[type-arg]
     """Remove sensitive data before sending."""
     if "extra" in event:
         for key in list(event["extra"]):
-            if any(s in key.lower() for s in _SCRUB_KEY_KEYWORDS):
+            if _is_sensitive_key(key.lower()):
                 event["extra"][key] = "[REDACTED]"
 
     if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
         for breadcrumb in event["breadcrumbs"]["values"]:
             if "message" in breadcrumb:
                 msg = str(breadcrumb["message"])
-                sensitive = any(s in msg.lower() for s in _SCRUB_MSG_KEYWORDS)
+                msg_lower = msg.lower()
+                keywords = ("password", "token", "secret", "credential")
+                sensitive = any(s in msg_lower for s in keywords)
                 if sensitive or _SCRUB_KEY_PATTERN.search(msg):
                     breadcrumb["message"] = "[REDACTED]"
             if "data" in breadcrumb and isinstance(breadcrumb["data"], dict):
                 for key in list(breadcrumb["data"]):
-                    if any(s in key.lower() for s in _SCRUB_KEY_KEYWORDS):
+                    if _is_sensitive_key(key.lower()):
                         breadcrumb["data"][key] = "[REDACTED]"
 
     return event
@@ -117,11 +143,11 @@
     try:
         import sentry_sdk  # noqa: PLC0415
     except ImportError:
-        logger.debug("sentry-sdk not installed; MQTT dump not sent")
+        _LOGGER.debug("sentry-sdk not installed; MQTT dump not sent")
         return False
 
     if not sentry_sdk.is_initialized():
-        logger.debug("Error reporting not initialized; MQTT dump not sent")
+        _LOGGER.debug("Error reporting not initialized; MQTT dump not sent")
         return False
 
     trimmed = messages[-max_messages:] if len(messages) > max_messages else messages
@@ -135,7 +161,7 @@
         level="info",
         extras={"mqtt_dump": dump, "message_count": len(scrubbed)},
     )
-    logger.info("MQTT dump sent to GlitchTip (%d messages)", len(scrubbed))
+    _LOGGER.info("MQTT dump sent to GlitchTip (%d messages)", len(scrubbed))
     return True
 
 

diff --git a/src/yarbo/local.py b/src/yarbo/local.py
--- a/src/yarbo/local.py
+++ b/src/yarbo/local.py
@@ -6,10 +6,10 @@
 
 Prerequisites:
 - The host machine must be on the same WiFi as the robot.
-- The robot's EMQX broker IP must be known (use :func:`yarbo.discover` or set explicitly).
+- The robot's EMQX broker IP must be known (default: 192.168.1.24).
 - ``paho-mqtt`` must be installed: ``pip install 'python-yarbo'``.
 
-Protocol notes (from hardware testing):
+Protocol notes (from live captures):
 - All MQTT payloads are zlib-compressed JSON (see ``_codec``).
 - ``get_controller`` MUST be sent before action commands (e.g. light_ctrl).
 - Topics: ``snowbot/{SN}/app/{cmd}`` (publish) and
@@ -17,14 +17,17 @@
 - Commands are generally fire-and-forget; responses on ``data_feedback``.
 
 Transport limitations (NOT YET IMPLEMENTED):
-- Local REST API (robot LAN, port 8088) — direct HTTP REST on the robot network.
+- Local REST API (``192.168.8.8:8088``) — direct HTTP REST on the robot network.
   Endpoints are unknown; requires further sniffing or SSH exploration.
-- Local TCP JSON (robot LAN, port 22220) — a JSON-over-TCP protocol discovered
+- Local TCP JSON (``192.168.8.1:22220``) — a JSON-over-TCP protocol discovered
   in libapp.so (uses ``com`` field with ``@n`` namespace notation).
 - This module is MQTT-only. Both unimplemented transports are TODO items.
 
 References:
-    Protocol documentation (command catalogue, light control protocol, MQTT protocol reference)
+    yarbo-reversing/scripts/local_ctrl.py — working reference implementation
+    yarbo-reversing/docs/COMMAND_CATALOGUE.md — full command catalogue
+    yarbo-reversing/docs/LIGHT_CTRL_PROTOCOL.md — light control protocol
+    yarbo-reversing/docs/MQTT_PROTOCOL.md — protocol reference
 """
 
 from __future__ import annotations
@@ -44,14 +47,7 @@
     TOPIC_LEAF_PLAN_FEEDBACK,
 )
 from .exceptions import YarboNotControllerError, YarboTimeoutError
-from .models import (
-    HeadType,
-    YarboCommandResult,
-    YarboLightState,
-    YarboPlan,
-    YarboSchedule,
-    YarboTelemetry,
-)
+from .models import YarboCommandResult, YarboLightState, YarboPlan, YarboSchedule, YarboTelemetry
 from .mqtt import MqttTransport
 
 if TYPE_CHECKING:
@@ -70,7 +66,7 @@
 
     Example (async context manager)::
 
-        async with YarboLocalClient(broker="<rover-ip>", sn="YOUR_SERIAL") as client:
+        async with YarboLocalClient(broker="192.168.1.24", sn="24400102L8HO5227") as client:
             await client.lights_on()
             await client.buzzer(state=1)
             async for telemetry in client.watch_telemetry():
@@ -78,63 +74,33 @@
 
     Example (manual lifecycle)::
 
-        client = YarboLocalClient(broker="<rover-ip>", sn="YOUR_SERIAL")
+        client = YarboLocalClient(broker="192.168.1.24", sn="24400102L8HO5227")
         await client.connect()
         await client.lights_on()
         await client.disconnect()
 
     Args:
-        broker:         MQTT broker IP (from discover() or set explicitly; required).
+        broker:         MQTT broker IP address.
         sn:             Robot serial number.
         port:           Broker port (default 1883).
         auto_controller: If ``True`` (default), automatically send
                          ``get_controller`` before the first action command.
-        mqtt_log_path:  If set, append every raw MQTT message (topic + payload JSON) to this file.
-        debug:          If ``True``, print every MQTT message sent/received to stderr
-                         (human-readable).
-        debug_raw:      If ``True`` and debug is on, print one-line JSON per message
-                         (no formatting).
-        mqtt_capture_max: If > 0, keep the last N messages in a buffer;
-                         use :meth:`get_captured_mqtt` to retrieve them
-                         (e.g. for ``report_mqtt_dump_to_glitchtip``).
     """
 
     def __init__(
         self,
-        broker: str,
+        broker: str = LOCAL_BROKER_DEFAULT,
         sn: str = "",
         port: int = LOCAL_PORT,
         auto_controller: bool = True,
-        mqtt_log_path: str | None = None,
-        debug: bool = False,
-        debug_raw: bool = False,
-        mqtt_capture_max: int = 0,
     ) -> None:
-        if not broker:
-            raise ValueError(
-                "broker IP must be set to the robot's EMQX broker address; "
-                "use yarbo.discovery.discover() to find it automatically."
-            )
         self._broker = broker
         self._sn = sn
         self._port = port
         self._auto_controller = auto_controller
-        self._transport = MqttTransport(
-            broker=broker,
-            sn=sn,
-            port=port,
-            mqtt_log_path=mqtt_log_path,
-            debug=debug,
-            debug_raw=debug_raw,
-            mqtt_capture_max=mqtt_capture_max,
-        )
+        self._transport = MqttTransport(broker=broker, sn=sn, port=port)
         self._controller_acquired = False
-        self._last_status: YarboTelemetry | None = None
 
-    def get_captured_mqtt(self) -> list[dict[str, Any]]:
-        """Return captured MQTT messages (when mqtt_capture_max > 0). For GlitchTip reports."""
-        return self._transport.get_captured_mqtt()
-
     # ------------------------------------------------------------------
     # Context manager
     # ------------------------------------------------------------------
@@ -166,7 +132,6 @@
     async def connect(self) -> None:
         """Connect to the local MQTT broker."""
         self._transport.add_reconnect_callback(self._on_reconnect)
-        logger.debug("Connecting to broker %s:%d (sn=%s)", self._broker, self._port, self._sn)
         await self._transport.connect()
         logger.info(
             "YarboLocalClient connected to %s:%d (sn=%s)",
@@ -177,7 +142,6 @@
 
     async def disconnect(self) -> None:
         """Disconnect from the local MQTT broker."""
-        logger.debug("Disconnecting from broker %s:%d (sn=%s)", self._broker, self._port, self._sn)
         await self._transport.disconnect()
 
     @property
@@ -342,7 +306,7 @@
             vel: Chute velocity / direction integer. Positive = right, negative = left.
 
         Reference:
-            Protocol documentation (light control protocol, cmd_chute section)
+            yarbo-reversing/docs/LIGHT_CTRL_PROTOCOL.md#cmd_chute
         """
         await self._ensure_controller()
         await self._transport.publish("cmd_chute", {"vel": vel})
@@ -369,15 +333,7 @@
         if envelope:
             topic = envelope.get("topic", "")
             payload = envelope.get("payload", {})
-            telemetry = YarboTelemetry.from_dict(payload, topic=topic)
-            self._last_status = telemetry
-            logger.debug(
-                "Received status snapshot: battery=%s state=%s head=%s",
-                telemetry.battery,
-                telemetry.state,
-                telemetry.head_name,
-            )
-            return telemetry
+            return YarboTelemetry.from_dict(payload, topic=topic)
         return None
 
     async def watch_telemetry(self) -> AsyncIterator[YarboTelemetry]:
@@ -410,59 +366,9 @@
                     t.plan_state = _plan_payload.get("state")
                     t.area_covered = _plan_payload.get("areaCovered")
                     t.duration = _plan_payload.get("duration")
-                self._last_status = t
-                logger.debug(
-                    "Telemetry: battery=%s state=%s head=%s",
-                    t.battery,
-                    t.state,
-                    t.head_name,
-                )
                 yield t
 
     # ------------------------------------------------------------------
-    # Head validation
-    # ------------------------------------------------------------------
-
-    def _validate_head_type(self, required: HeadType | tuple[HeadType, ...]) -> None:
-        """Validate that the attached head matches the required type(s).
-
-        Args:
-            required: A single :class:`~yarbo.models.HeadType` or a tuple of
-                      acceptable head types.
-
-        Raises:
-            ValueError: If a head status has been received and the attached head
-                        does not match *required*.
-
-        If no status has been received yet (``_last_status`` is ``None`` or
-        ``head_type`` is absent), a warning is logged and the command is allowed
-        through to preserve compatibility with firmware that reports head type
... diff truncated: showing 800 of 2688 lines

[cursor]

Cursor Bugbot has reviewed your changes and found 2 potential issues.

Bugbot Autofix prepared fixes for both issues found in the latest run.

• ✅ Fixed: CLI debug and logging flags silently ignored
  • Added mqtt_log_path, debug, debug_raw, and mqtt_capture_max parameters to both YarboLocalClient constructor calls in _with_client() function.
• ✅ Fixed: Wrapper parameter and docstring mismatch after semantic change
  • Updated set_chute_steering_work method parameter from 'state' to 'angle' and changed docstring to reflect angle-based API.

Preview (e3acf14f82)

diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
new file mode 100644
--- /dev/null
+++ b/.github/codeql/codeql-config.yml
@@ -1,0 +1,20 @@
+name: "Yarbo CodeQL Config"
+
+# Disable queries that flag core IoT features as privacy issues
+# GPS coordinates, IP addresses, MAC addresses, and hostnames are
+# fundamental to robot mower discovery and control — not PII leaks.
+query-filters:
+  - exclude:
+      tags contain: security/cwe/cwe-532  # Clear-text logging (we handle this ourselves)
+  - exclude:
+      tags contain: security/cwe/cwe-359  # Privacy violation (GPS, IP, MAC are core features)
+  - exclude:
+      tags contain: security/cwe/cwe-200  # Information exposure (device telemetry is the product)
+  - exclude:
+      id: py/clear-text-logging-sensitive-data
+  - exclude:
+      id: py/clear-text-storage-sensitive-data
+
+paths-ignore:
+  - tests
+  - archive

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -1,0 +1,27 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+permissions:
+  security-events: write
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        language: [python]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: github/codeql-action/init@v3
+        with:
+          languages: ${{ matrix.language }}
+          config-file: .github/codeql/codeql-config.yml
+      - uses: github/codeql-action/autobuild@v3
+      - uses: github/codeql-action/analyze@v3

diff --git a/pyproject.toml b/pyproject.toml
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,10 +25,12 @@
 dependencies = [
     "paho-mqtt>=2.0",
     "aiohttp>=3.9",
-    "sentry-sdk>=2.0",
 ]
 
 [project.optional-dependencies]
+sentry = [
+    "sentry-sdk>=2.0",
+]
 cloud = [
     "cryptography>=42.0",
 ]

diff --git a/src/yarbo/__init__.py b/src/yarbo/__init__.py
--- a/src/yarbo/__init__.py
+++ b/src/yarbo/__init__.py
@@ -1,5 +1,5 @@
 """
-yarbo — Python library for local and cloud control of Yarbo robot mowers.
+yarbo — Python library for local control of Yarbo robot mowers and snow blowers via MQTT.
 
 Yarbo makes autonomous snow blowers and lawn mowers controlled via local MQTT.
 This is a community-developed library for the Yarbo protocol, built through
@@ -58,7 +58,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __author__ = "Markus Lassfolk"
 __license__ = "MIT"
 

diff --git a/src/yarbo/_cli.py b/src/yarbo/_cli.py
--- a/src/yarbo/_cli.py
+++ b/src/yarbo/_cli.py
@@ -20,7 +20,6 @@
 from typing import TYPE_CHECKING, Any
 
 from yarbo.discovery import connection_order, discover
-from yarbo.error_reporting import report_mqtt_dump_to_glitchtip
 from yarbo.exceptions import YarboError
 from yarbo.local import YarboLocalClient
 
@@ -78,7 +77,6 @@
 Debug and reporting
   --debug       Print every MQTT message sent/received (human-readable). Also YARBO_DEBUG=1.
   --raw         With --debug, print raw one-line JSON per message.
-  --report-mqtt Capture MQTT and send a dump to GlitchTip (for support/firmware issues).
   --log-mqtt F  Append raw MQTT (topic + payload JSON) to file F.
 
 Test (with robot on network; omit --broker/--sn to auto-discover)
@@ -183,12 +181,6 @@
         dest="debug_raw",
         help="With --debug, print raw one-line JSON per message (no formatting).",
     )
-    parser.add_argument(
-        "--report-mqtt",
-        action="store_true",
-        dest="report_mqtt",
-        help="Capture MQTT traffic for this run and send a dump to GlitchTip (for support).",
-    )
 
 
 def _apply_debug_env(args: argparse.Namespace) -> None:
@@ -199,16 +191,6 @@
         args.debug_raw = os.environ.get("YARBO_DEBUG_RAW", "").lower() in ("1", "true", "yes")
 
 
-def _mqtt_capture_max(args: argparse.Namespace) -> int:
-    return 1000 if getattr(args, "report_mqtt", False) else 0
-
-
-def _maybe_report_mqtt(args: argparse.Namespace, client: YarboLocalClient) -> None:
-    """If --report-mqtt was set, send captured MQTT dump to GlitchTip."""
-    if getattr(args, "report_mqtt", False):
-        report_mqtt_dump_to_glitchtip(client.get_captured_mqtt())
-
-
 async def _with_client(
     args: argparse.Namespace,
 ) -> AsyncIterator[tuple[YarboLocalClient, str | None]]:
@@ -221,7 +203,7 @@
             mqtt_log_path=getattr(args, "log_mqtt", None),
             debug=getattr(args, "debug", False),
             debug_raw=getattr(args, "debug_raw", False),
-            mqtt_capture_max=_mqtt_capture_max(args),
+            mqtt_capture_max=0,
         )
         await client.connect()
         try:
@@ -251,7 +233,7 @@
                 mqtt_log_path=getattr(args, "log_mqtt", None),
                 debug=getattr(args, "debug", False),
                 debug_raw=getattr(args, "debug_raw", False),
-                mqtt_capture_max=_mqtt_capture_max(args),
+                mqtt_capture_max=0,
             )
             await client.connect()
         except (YarboError, OSError, TimeoutError) as e:
@@ -500,7 +482,6 @@
         else:
             print("Error: connected but no telemetry received within timeout.")
             sys.exit(1)
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -629,7 +610,6 @@
     async for client, _ in _with_client(args):
         status = await asyncio.wait_for(client.get_status(), timeout=args.timeout)
         print(f"{status.battery}%" if status and status.battery is not None else "?")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -643,7 +623,6 @@
                 print(f"  Battery: {bat}%  State: {state}")
         except asyncio.CancelledError:
             break
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -651,7 +630,6 @@
     async for client, _ in _with_client(args):
         await client.lights_on()
         print("Lights on.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -659,7 +637,6 @@
     async for client, _ in _with_client(args):
         await client.lights_off()
         print("Lights off.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -667,7 +644,6 @@
     async for client, _ in _with_client(args):
         await client.buzzer(state=0 if getattr(args, "stop", False) else 1)
         print("Buzzer stopped." if getattr(args, "stop", False) else "Buzzer on.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -675,7 +651,6 @@
     async for client, _ in _with_client(args):
         await client.set_chute(vel=args.vel)
         print(f"Chute set to {args.vel}.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -683,7 +658,6 @@
     async for client, _ in _with_client(args):
         result = await client.return_to_dock()
         print("Return to dock sent.", result)
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -694,7 +668,6 @@
             print(f"  {p.plan_id}: {p.plan_name}")
         if not plans:
             print("No plans.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -702,7 +675,6 @@
     async for client, _ in _with_client(args):
         result = await client.start_plan(plan_id=args.plan_id)
         print("Plan started.", result)
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -710,7 +682,6 @@
     async for client, _ in _with_client(args):
         result = await client.stop_plan()
         print("Plan stopped.", result)
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -718,7 +689,6 @@
     async for client, _ in _with_client(args):
         result = await client.pause_plan()
         print("Plan paused.", result)
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -726,7 +696,6 @@
     async for client, _ in _with_client(args):
         result = await client.resume_plan()
         print("Plan resumed.", result)
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -737,7 +706,6 @@
             print(f"  {s.schedule_id}: {s}")
         if not schedules:
             print("No schedules.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -745,7 +713,6 @@
     async for client, _ in _with_client(args):
         await client.start_manual_drive()
         print("Manual drive started.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -753,7 +720,6 @@
     async for client, _ in _with_client(args):
         await client.set_velocity(linear=args.linear, angular=args.angular)
         print(f"Velocity set: linear={args.linear}, angular={args.angular}.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -761,7 +727,6 @@
     async for client, _ in _with_client(args):
         await client.set_roller(speed=args.speed)
         print(f"Roller speed set to {args.speed}.")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -771,7 +736,6 @@
         emergency = args.mode == "emergency"
         await client.stop_manual_drive(hard=hard, emergency=emergency)
         print(f"Manual drive stopped ({args.mode}).")
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -779,7 +743,6 @@
     async for client, _ in _with_client(args):
         params = await asyncio.wait_for(client.get_global_params(), timeout=args.timeout)
         print(json.dumps(params, indent=2))
-        _maybe_report_mqtt(args, client)
         break
 
 
@@ -794,7 +757,6 @@
             print(f"Map written to {out}.")
         else:
             print(s)
-        _maybe_report_mqtt(args, client)
         break
 
 

diff --git a/src/yarbo/client.py b/src/yarbo/client.py
--- a/src/yarbo/client.py
+++ b/src/yarbo/client.py
@@ -204,6 +204,300 @@
         """Publish an arbitrary MQTT command to the robot."""
         await self._local.publish_raw(cmd, payload)
 
+    async def publish_command(self, cmd: str, payload: dict[str, Any]) -> None:
+        """Alias for :meth:`publish_raw` — publish an arbitrary MQTT command to the robot."""
+        await self._local.publish_command(cmd, payload)
+
+    # -- Robot control --
+
+    async def shutdown(self) -> None:
+        """Power off the robot."""
+        await self._local.shutdown()
+
+    async def restart_container(self) -> None:
+        """Restart the EMQX container on the robot."""
+        await self._local.restart_container()
+
+    async def emergency_stop(self) -> None:
+        """Trigger an emergency stop."""
+        await self._local.emergency_stop()
+
+    async def emergency_unlock(self) -> None:
+        """Clear the emergency stop state."""
+        await self._local.emergency_unlock()
+
+    async def dstop(self) -> None:
+        """Soft-stop the robot (decelerate to halt)."""
+        await self._local.dstop()
+
+    async def resume(self) -> None:
+        """Resume operation after a pause or soft-stop."""
+        await self._local.resume()
+
+    async def cmd_recharge(self) -> None:
+        """Send the robot back to its charging dock."""
+        await self._local.cmd_recharge()
+
+    # -- Lights & sound --
+
+    async def set_head_light(self, enabled: bool) -> None:
+        """Enable or disable the head light."""
+        await self._local.set_head_light(enabled)
+
+    async def set_roof_lights(self, enabled: bool) -> None:
+        """Enable or disable the roof lights."""
+        await self._local.set_roof_lights(enabled)
+
+    async def set_laser(self, enabled: bool) -> None:
+        """Enable or disable the laser."""
+        await self._local.set_laser(enabled)
+
+    async def set_sound(self, volume: int, song_id: int = 0) -> None:
+        """Set the speaker volume (0-100)."""
+        await self._local.set_sound(volume, song_id)
+
+    async def play_song(self, song_id: int) -> None:
+        """Play a sound/song by ID."""
+        await self._local.play_song(song_id)
+
+    # -- Camera & detection --
+
+    async def set_camera(self, enabled: bool) -> None:
+        """Enable or disable the camera."""
+        await self._local.set_camera(enabled)
+
+    async def set_person_detect(self, enabled: bool) -> None:
+        """Enable or disable person detection."""
+        await self._local.set_person_detect(enabled)
+
+    async def set_usb(self, enabled: bool) -> None:
+        """Enable or disable the USB port."""
+        await self._local.set_usb(enabled)
+
+    # -- Plans & scheduling --
+
+    async def start_plan_direct(self, plan_id: int, percent: int = 100) -> None:
+        """Start a work plan by numeric ID (direct command, no response)."""
+        await self._local.start_plan_direct(plan_id, percent)
+
+    async def read_plan(self, plan_id: int, timeout: float = 5.0) -> dict[str, Any]:
+        """Request plan detail and await the data_feedback response."""
+        return await self._local.read_plan(plan_id, timeout)
+
+    async def read_all_plans(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all plan summaries and await the data_feedback response."""
+        return await self._local.read_all_plans(timeout)
+
+    async def delete_plan_direct(self, plan_id: int, confirm: bool = False) -> None:
+        """Delete a plan by numeric ID. Pass confirm=True to proceed (destructive)."""
+        await self._local.delete_plan_direct(plan_id, confirm=confirm)
+
+    async def delete_all_plans(self, confirm: bool = False) -> None:
+        """Delete all stored plans from the robot. Pass confirm=True to proceed (destructive)."""
+        await self._local.delete_all_plans(confirm=confirm)
+
+    async def pause_planning(self) -> None:
+        """Pause the currently running plan (direct command, no response)."""
+        await self._local.pause_planning()
+
+    async def in_plan_action(self, action: str) -> None:
+        """Send an in-plan action command."""
+        await self._local.in_plan_action(action)
+
+    async def read_schedules(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all schedules and await the data_feedback response."""
+        return await self._local.read_schedules(timeout)
+
+    # -- Navigation & maps --
+
+    async def start_waypoint(self, index: int) -> None:
+        """Start navigation to a waypoint by index."""
+        await self._local.start_waypoint(index)
+
+    async def read_recharge_point(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the saved recharge/dock point and await the data_feedback response."""
+        return await self._local.read_recharge_point(timeout)
+
+    async def save_charging_point(self) -> None:
+        """Save the robot's current position as the charging/dock point."""
+        await self._local.save_charging_point()
+
+    async def read_clean_area(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the clean area definition and await the data_feedback response."""
+        return await self._local.read_clean_area(timeout)
+
+    async def get_all_map_backup(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request all map backups and await the data_feedback response."""
+        return await self._local.get_all_map_backup(timeout)
+
+    async def save_map_backup(self) -> None:
+        """Save a backup of the current map."""
+        await self._local.save_map_backup()
+
+    # -- WiFi & connectivity --
+
+    async def get_wifi_list(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the list of available WiFi networks and await the data_feedback response."""
+        return await self._local.get_wifi_list(timeout)
+
+    async def get_connected_wifi(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the connected WiFi network name and await the data_feedback response."""
+        return await self._local.get_connected_wifi(timeout)
+
+    async def start_hotspot(self) -> None:
+        """Start the robot's WiFi hotspot."""
+        await self._local.start_hotspot()
+
+    async def get_hub_info(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request hub information and await the data_feedback response."""
+        return await self._local.get_hub_info(timeout)
+
+    # -- Diagnostics --
+
+    async def read_no_charge_period(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request no-charge period configuration and await the data_feedback response."""
+        return await self._local.read_no_charge_period(timeout)
+
+    async def get_battery_cell_temps(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request battery cell temperature data and await the data_feedback response."""
+        return await self._local.get_battery_cell_temps(timeout)
+
+    async def get_motor_temps(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request motor temperature data and await the data_feedback response."""
+        return await self._local.get_motor_temps(timeout)
+
+    async def get_body_current(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request body current telemetry and await the data_feedback response."""
+        return await self._local.get_body_current(timeout)
+
+    async def get_head_current(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request head current telemetry and await the data_feedback response."""
+        return await self._local.get_head_current(timeout)
+
+    async def get_speed(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request current speed telemetry and await the data_feedback response."""
+        return await self._local.get_speed(timeout)
+
+    async def get_odometer(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request odometer data and await the data_feedback response."""
+        return await self._local.get_odometer(timeout)
+
+    async def get_product_code(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Request the product code and await the data_feedback response."""
+        return await self._local.get_product_code(timeout)
+
+    async def set_charge_limit(self, min_pct: int, max_pct: int) -> None:
+        """Set battery charge limits."""
+        await self._local.set_charge_limit(min_pct, max_pct)
+
+    async def set_turn_type(self, turn_type: int) -> None:
+        """Set the turning behaviour type."""
+        await self._local.set_turn_type(turn_type)
+
+    # -- Motor & mechanical --
+
+    async def set_motor_protect(self, state: int) -> None:
+        """Enable or disable motor protection mode."""
+        await self._local.set_motor_protect(state)
+
+    async def set_trimmer(self, state: int) -> None:
+        """Enable or disable the trimmer."""
+        await self._local.set_trimmer(state)
+
+    # -- Blowing / edge / smart features --
+
+    async def set_edge_blowing(self, state: int) -> None:
+        """Enable or disable edge blowing."""
+        await self._local.set_edge_blowing(state)
+
+    async def set_smart_blowing(self, state: int) -> None:
+        """Enable or disable smart blowing."""
+        await self._local.set_smart_blowing(state)
+
+    async def set_heating_film(self, state: int) -> None:
+        """Enable or disable heating film (anti-ice)."""
+        await self._local.set_heating_film(state)
+
+    async def set_module_lock(self, state: int) -> None:
+        """Lock or unlock an accessory module."""
+        await self._local.set_module_lock(state)
+
+    # -- Autonomous modes --
+
+    async def set_follow_mode(self, state: int) -> None:
+        """Enable or disable follow mode."""
+        await self._local.set_follow_mode(state)
+
+    async def set_draw_mode(self, state: int) -> None:
+        """Enable or disable draw/mapping mode."""
+        await self._local.set_draw_mode(state)
+
+    # -- OTA / firmware updates --
+
+    async def set_auto_update(self, state: int) -> None:
+        """Enable or disable automatic firmware (Greengrass) updates."""
+        await self._local.set_auto_update(state)
+
+    async def set_camera_ota(self, state: int) -> None:
+        """Enable or disable IP camera OTA updates."""
+        await self._local.set_camera_ota(state)
+
+    # -- Vision / recording --
+
+    async def set_smart_vision(self, state: int) -> None:
+        """Enable or disable smart vision processing."""
+        await self._local.set_smart_vision(state)
+
+    async def set_video_record(self, state: int) -> None:
+        """Enable or disable video recording."""
+        await self._local.set_video_record(state)
+
+    # -- Safety / fencing --
+
+    async def set_child_lock(self, state: int) -> None:
+        """Enable or disable the child lock."""
+        await self._local.set_child_lock(state)
+
+    async def set_geo_fence(self, state: int) -> None:
+        """Enable or disable geo-fencing."""
+        await self._local.set_geo_fence(state)
+
+    async def set_elec_fence(self, state: int) -> None:
+        """Enable or disable the electric fence."""
+        await self._local.set_elec_fence(state)
+
+    async def set_ngz_edge(self, state: int) -> None:
+        """Enable or disable NGZ edge enforcement."""
+        await self._local.set_ngz_edge(state)
+
+    # -- Manual drive extras --
+
+    async def set_velocity_manual(self, linear: float, angular: float) -> None:
+        """Send a velocity command in manual drive mode."""
+        await self._local.set_velocity_manual(linear, angular)
+
+    async def set_sound_param(self, volume: int, enabled: int) -> None:
+        """Set sound volume and enable/disable audio output."""
+        await self._local.set_sound_param(volume, enabled)
+
+    # -- Map management (destructive) --
+
+    async def erase_map(self, confirm: bool = False) -> None:
+        """Erase the robot's stored map. Pass confirm=True to proceed (destructive)."""
+        await self._local.erase_map(confirm=confirm)
+
+    async def map_recovery(self, map_id: str, confirm: bool = False) -> None:
+        """Restore a map from backup. Pass confirm=True to proceed (destructive)."""
+        await self._local.map_recovery(map_id, confirm=confirm)
+
+    async def save_current_map(self) -> None:
+        """Save the robot's current map state."""
+        await self._local.save_current_map()
+
+    async def save_map_backup_list(self, timeout: float = 5.0) -> dict[str, Any]:
+        """Save map backup and retrieve all map backup names and IDs."""
+        return await self._local.save_map_backup_list(timeout)
+
     # ------------------------------------------------------------------
     # Plan management (delegated to YarboLocalClient)
     # ------------------------------------------------------------------
@@ -342,9 +636,9 @@
         """Set snow push direction (snow blower head only)."""
         return await self._local.push_snow_dir(direction=direction)
 
-    async def set_chute_steering_work(self, state: int) -> None:
-        """Enable or disable chute auto-steering (snow blower head only)."""
-        return await self._local.set_chute_steering_work(state=state)
+    async def set_chute_steering_work(self, angle: int) -> None:
+        """Set chute steering angle during work (snow blower head only)."""
+        return await self._local.set_chute_steering_work(angle=angle)
 
     # ------------------------------------------------------------------
     # Camera commands (delegated to YarboLocalClient)

diff --git a/src/yarbo/error_reporting.py b/src/yarbo/error_reporting.py
--- a/src/yarbo/error_reporting.py
+++ b/src/yarbo/error_reporting.py
@@ -8,16 +8,12 @@
 
 import json
 import logging
+import os
 import re
 from typing import Any
 
-logger = logging.getLogger(__name__)
+_LOGGER = logging.getLogger(__name__)
 
-# Sensitive-key scrubbing helpers — compiled once at import time.
-_SCRUB_KEY_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential", "key")
-_SCRUB_MSG_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential")
-_SCRUB_KEY_PATTERN = re.compile(r"(?:_|api|access|auth|private)key", re.IGNORECASE)
-
 # Default DSN for the python-yarbo GlitchTip project.
 # Enabled by default during beta to help find issues.
 # Opt-out: set YARBO_SENTRY_DSN="" or pass enabled=False.
@@ -28,8 +24,9 @@
     dsn: str | None = None,
     environment: str = "production",
     enabled: bool = True,
+    tags: dict[str, str] | None = None,
 ) -> None:
-    """Initialize Sentry/GlitchTip error reporting.
+    """Initialize Sentry/GlitchTip error reporting for python-yarbo.
 
     Enabled by default during beta with a built-in DSN. No PII is collected;
     credentials and sensitive keys are scrubbed before sending.
@@ -41,56 +38,85 @@
              ``SENTRY_DSN`` environment variables, then the built-in default.
         environment: Environment tag (production/development/testing).
         enabled: Master switch. If False, no SDK initialization occurs.
+        tags: Optional extra tags (e.g. robot_serial, library_version).
     """
     if not enabled:
         return
 
-    import os  # noqa: PLC0415
-
-    # Check for explicit disable via empty env var
+    # Resolve DSN: explicit arg > YARBO_SENTRY_DSN env var > SENTRY_DSN env var > built-in default
     env_dsn = os.environ.get("YARBO_SENTRY_DSN")
     if env_dsn is not None and env_dsn == "":
-        return  # Explicitly disabled
+        _LOGGER.debug('Error reporting explicitly disabled via YARBO_SENTRY_DSN=""')
+        return
+    effective_dsn = dsn or env_dsn or os.environ.get("SENTRY_DSN") or _DEFAULT_DSN
 
-    dsn = dsn or env_dsn or os.environ.get("SENTRY_DSN") or _DEFAULT_DSN
-
-    if not dsn:
+    if not effective_dsn:
         return
 
     try:
         import sentry_sdk  # noqa: PLC0415
 
         sentry_sdk.init(
-            dsn=dsn,
+            dsn=effective_dsn,
             environment=environment,
             traces_sample_rate=0.1,
             send_default_pii=False,
-            before_send=_scrub_event,  # type: ignore[arg-type, unused-ignore]
+            before_send=_scrub_event,
         )
-        logger.debug("Error reporting initialized (dsn=%s...)", dsn[:30])
+
+        if tags:
+            for key, value in tags.items():
+                sentry_sdk.set_tag(key, value)
+
+        _LOGGER.debug("Error reporting initialized (dsn=%s...)", effective_dsn[:30])
     except ImportError:
-        logger.debug("sentry-sdk not installed; error reporting disabled")
+        _LOGGER.debug("sentry-sdk not installed; error reporting disabled")
     except Exception as exc:  # noqa: BLE001
-        logger.warning("Failed to initialize error reporting: %s", exc)
+        _LOGGER.warning("Failed to initialize error reporting: %s", exc)
 
 
+# Non-sensitive field names that contain "_key" but must not be redacted.
+_KEY_ALLOWLIST: frozenset[str] = frozenset({"entity_key"})
+
+# Pattern to detect key-like strings in breadcrumb messages (e.g., "apikey", "access_key")
+_SCRUB_KEY_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential", "key")
+_SCRUB_MSG_KEYWORDS: tuple[str, ...] = ("password", "token", "secret", "credential")
+_SCRUB_KEY_PATTERN = re.compile(r"(?:_|api|access|auth|private)key", re.IGNORECASE)
+
+
+def _is_sensitive_key(key_lower: str) -> bool:
+    """Check if a key name looks sensitive and should be redacted."""
+    if any(s in key_lower for s in ("password", "token", "secret", "credential")):
+        return True
+    if key_lower in _KEY_ALLOWLIST:
+        return False
+    return (
+        key_lower == "key"
+        or "_key" in key_lower
+        or key_lower.startswith("key_")
+        or key_lower.endswith("key")
+    )
+
+
 def _scrub_event(event: dict, hint: dict) -> dict:  # type: ignore[type-arg]
     """Remove sensitive data before sending."""
     if "extra" in event:
         for key in list(event["extra"]):
-            if any(s in key.lower() for s in _SCRUB_KEY_KEYWORDS):
+            if _is_sensitive_key(key.lower()):
                 event["extra"][key] = "[REDACTED]"
 
     if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
         for breadcrumb in event["breadcrumbs"]["values"]:
             if "message" in breadcrumb:
                 msg = str(breadcrumb["message"])
-                sensitive = any(s in msg.lower() for s in _SCRUB_MSG_KEYWORDS)
+                msg_lower = msg.lower()
+                keywords = ("password", "token", "secret", "credential")
+                sensitive = any(s in msg_lower for s in keywords)
                 if sensitive or _SCRUB_KEY_PATTERN.search(msg):
                     breadcrumb["message"] = "[REDACTED]"
             if "data" in breadcrumb and isinstance(breadcrumb["data"], dict):
                 for key in list(breadcrumb["data"]):
-                    if any(s in key.lower() for s in _SCRUB_KEY_KEYWORDS):
+                    if _is_sensitive_key(key.lower()):
                         breadcrumb["data"][key] = "[REDACTED]"
 
     return event
@@ -117,11 +143,11 @@
     try:
         import sentry_sdk  # noqa: PLC0415
     except ImportError:
-        logger.debug("sentry-sdk not installed; MQTT dump not sent")
+        _LOGGER.debug("sentry-sdk not installed; MQTT dump not sent")
         return False
 
     if not sentry_sdk.is_initialized():
-        logger.debug("Error reporting not initialized; MQTT dump not sent")
+        _LOGGER.debug("Error reporting not initialized; MQTT dump not sent")
         return False
 
     trimmed = messages[-max_messages:] if len(messages) > max_messages else messages
@@ -135,7 +161,7 @@
         level="info",
         extras={"mqtt_dump": dump, "message_count": len(scrubbed)},
     )
-    logger.info("MQTT dump sent to GlitchTip (%d messages)", len(scrubbed))
+    _LOGGER.info("MQTT dump sent to GlitchTip (%d messages)", len(scrubbed))
     return True
 
 
... diff truncated: showing 800 of 2805 lines