updates

README.md

@@ -179,7 +179,7 @@ This prevents messages from being overwritten when using Claude Desktop on multi
 - **Timed wakes**: CMD+R ensures chat is synced before system check message
 - **Matrix wakes**: CMD+R ensures you see the latest conversation context
 
-The daemon waits **10 seconds** after sending CMD+R to ensure the refresh completes before sending the message.
+The daemon waits **15 seconds** after sending CMD+R to ensure the refresh completes before sending the message.
 
 **Why this matters:**
 - Multi-device sync: If you're active on mobile/web, desktop chat stays current
@@ -277,14 +277,6 @@ def generate_message() -> str:
     return f"Your custom message template with {timestamp}"
 ```
 
-### Grace Period
-
-After sending a message, the daemon waits 30 seconds for Claude to call MCP tools. Adjust in `automation_daemon.py` line 246:
-
-```python
-grace_period = 30  # seconds
-```
-
 ## Monitoring
 
 ### Logs
@@ -707,7 +699,7 @@ claude-desktop-automation/
 ⚠️ **macOS only** - Uses AppleScript and launchd (Linux port would require xdotool/ydotool)
 ⚠️ **Requires Accessibility** - Special macOS permissions for UI automation
 ⚠️ **Screen saver handled** - Uses `caffeinate` to wake screen automatically
-⚠️ **Fixed refresh delay** - Waits 10 seconds after CMD+R (configurable if needed)
+⚠️ **Fixed refresh delay** - Waits 15 seconds after CMD+R (configurable if needed)
 
 ## Future Plans
 

matrix_helpers.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""
+Matrix Helper Utilities
+
+Shared utilities for Matrix client operations, reducing code duplication
+across matrix_mcp.py and matrix_integration.py.
+"""
+
+import json
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncIterator
+
+try:
+    from nio import AsyncClient
+except ImportError:
+    raise ImportError(
+        "matrix-nio not installed. Install with: pip3 install matrix-nio\n"
+        "Note: Without [e2e] extra, only unencrypted rooms are supported"
+    )
+
+# Configuration
+CREDENTIALS_FILE = Path.home() / ".matrix-credentials.json"
+MATRIX_DATA_DIR = Path.home() / ".matrix-data"
+
+logger = logging.getLogger(__name__)
+
+
+def load_credentials() -> dict:
+    """Load Matrix credentials from JSON file"""
+    if not CREDENTIALS_FILE.exists():
+        raise FileNotFoundError(
+            f"Credentials file not found: {CREDENTIALS_FILE}\n"
+            f"Run setup_matrix.sh to create credentials"
+        )
+
+    try:
+        with open(CREDENTIALS_FILE, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to load credentials: {e}")
+        raise
+
+
+@asynccontextmanager
+async def matrix_client() -> AsyncIterator[AsyncClient]:
+    """
+    Async context manager for Matrix client operations.
+
+    Handles client setup, session restoration, and cleanup automatically.
+    Ensures client.close() is always called, preventing resource leaks.
+
+    Usage:
+        async with matrix_client() as client:
+            response = await client.room_send(...)
+
+    Yields:
+        AsyncClient: Configured and authenticated Matrix client
+    """
+    creds = load_credentials()
+
+    # Create data directory for E2EE store
+    MATRIX_DATA_DIR.mkdir(exist_ok=True)
+
+    client = AsyncClient(
+        homeserver=creds['homeserver'],
+        user=creds['user_id'],
+        store_path=str(MATRIX_DATA_DIR),
+    )
+
+    # Restore session from credentials
+    client.access_token = creds['access_token']
+    client.device_id = creds['device_id']
+
+    try:
+        yield client
+    finally:
+        await client.close()

matrix_integration.py

@@ -449,7 +449,7 @@ class MatrixMonitor:
                 # Trigger wake if rate limit allows
                 await self._maybe_trigger_wake()
             else:
-                logger.warning(f"Failed to download/compress image: {event.body}")
+                logger.warning(f"Image rejected (too large or download failed): {event.body}")
 
         except Exception as e:
             logger.error(f"Error processing image: {e}")
@@ -596,7 +596,19 @@ class MatrixMonitor:
             buffer = BytesIO()
             final_img = img.resize((800, 600), Image.Resampling.LANCZOS)
             final_img.save(buffer, format='JPEG', quality=50, optimize=True)
-            return buffer.getvalue()
+            final_data = buffer.getvalue()
+
+            # Final size validation - reject if still too large
+            final_base64 = base64.b64encode(final_data)
+            final_size_mb = len(final_base64) / (1024 * 1024)
+            if final_size_mb > target_size_mb:
+                logger.error(
+                    f"Image still too large after all compression attempts: "
+                    f"{final_size_mb:.2f}MB base64 (limit: {target_size_mb}MB)"
+                )
+                return None
+
+            return final_data
 
         except Exception as e:
             logger.error(f"Compression failed: {e}")

matrix_mcp.py

@@ -33,6 +33,8 @@ from typing import List, Optional, Dict, Any
 from mcp.server.fastmcp import FastMCP
 from mcp.server.fastmcp.utilities.types import Image as MCPImage
 
+from matrix_helpers import matrix_client, load_credentials as load_credentials_helper
+
 try:
     from nio import (
         AsyncClient,
@@ -429,6 +431,7 @@ async def matrix_send_image(room_id: str, file_path: str) -> str:
         from pathlib import Path
         from io import BytesIO
         from PIL import Image
+        import aiohttp
 
         # Resolve path
         path = Path(file_path).expanduser().resolve()
@@ -455,27 +458,13 @@ async def matrix_send_image(room_id: str, file_path: str) -> str:
             width, height = None, None
             mime_type = 'image/jpeg'
 
-        # Load credentials
+        # Load credentials for upload URL
         creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Upload image to Matrix homeserver using aiohttp directly
-        # (nio's upload has timeout issues)
         filename = path.name
         logger.info(f"Uploading image from file: {filename} ({len(image_data)} bytes)")
 
-        import aiohttp
+        # Upload image to Matrix homeserver using aiohttp directly
+        # (nio's upload has timeout issues)
         upload_url = f"{creds['homeserver']}/_matrix/media/v3/upload?filename={filename}"
         headers = {
             "Authorization": f"Bearer {creds['access_token']}",
@@ -490,11 +479,10 @@ async def matrix_send_image(room_id: str, file_path: str) -> str:
                     logger.info(f"Upload successful: {content_uri}")
                 else:
                     error_text = await resp.text()
-                    await client.close()
                     logger.error(f"Upload failed: {resp.status} - {error_text}")
                     return f"Error uploading image: {resp.status} - {error_text}"
 
-        # Send image message
+        # Send image message using context manager
         content = {
             "msgtype": "m.image",
             "body": filename,
@@ -509,14 +497,13 @@ async def matrix_send_image(room_id: str, file_path: str) -> str:
             content["info"]["w"] = width
             content["info"]["h"] = height
 
+        async with matrix_client() as client:
             response = await client.room_send(
                 room_id=room_id,
                 message_type="m.room.message",
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent image to {room_id}: {filename}")
                 return f"✓ Image sent to room: {filename} (event ID: {response.event_id})"
@@ -554,6 +541,7 @@ async def matrix_send_voice(room_id: str, file_path: str) -> str:
     try:
         from pathlib import Path
         import wave
+        import aiohttp
 
         # Resolve path
         path = Path(file_path).expanduser().resolve()
@@ -595,27 +583,13 @@ async def matrix_send_voice(room_id: str, file_path: str) -> str:
             except Exception as e:
                 logger.warning(f"Could not extract WAV duration: {e}")
 
-        # Load credentials
+        # Load credentials for upload URL
         creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Upload audio to Matrix homeserver using aiohttp directly
-        # (nio's upload has timeout issues)
         filename = path.name
         logger.info(f"Uploading voice message from file: {filename} ({len(audio_data)} bytes)")
 
-        import aiohttp
+        # Upload audio to Matrix homeserver using aiohttp directly
+        # (nio's upload has timeout issues)
         upload_url = f"{creds['homeserver']}/_matrix/media/v3/upload?filename={filename}"
         headers = {
             "Authorization": f"Bearer {creds['access_token']}",
@@ -630,11 +604,10 @@ async def matrix_send_voice(room_id: str, file_path: str) -> str:
                     logger.info(f"Upload successful: {content_uri}")
                 else:
                     error_text = await resp.text()
-                    await client.close()
                     logger.error(f"Upload failed: {resp.status} - {error_text}")
                     return f"Error uploading audio: {resp.status} - {error_text}"
 
-        # Send voice message
+        # Send voice message using context manager
         content = {
             "msgtype": "m.audio",
             "body": filename,
@@ -649,14 +622,13 @@ async def matrix_send_voice(room_id: str, file_path: str) -> str:
         if duration_ms:
             content["info"]["duration"] = duration_ms
 
+        async with matrix_client() as client:
             response = await client.room_send(
                 room_id=room_id,
                 message_type="m.room.message",
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent voice message to {room_id}: {filename}")
                 return f"✓ Voice message sent to room: {filename} (event ID: {response.event_id})"
@@ -713,21 +685,6 @@ async def matrix_send_message(room_id: str, message: str) -> str:
         matrix_send_message("!abc123:matrix.org", "This is **bold** and *italic*")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
         # Convert markdown to HTML
         html_body = _convert_markdown_to_html(message)
 
@@ -742,15 +699,13 @@ async def matrix_send_message(room_id: str, message: str) -> str:
             content["format"] = "org.matrix.custom.html"
             content["formatted_body"] = html_body
 
-        # Send message
+        async with matrix_client() as client:
             response = await client.room_send(
                 room_id=room_id,
                 message_type="m.room.message",
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent message to {room_id}: {message[:50]}...")
                 return f"✓ Message sent to room (event ID: {response.event_id})"
@@ -785,21 +740,6 @@ async def matrix_send_emote(room_id: str, action: str) -> str:
         matrix_send_emote("!abc123:matrix.org", "is **thinking** carefully")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
         # Convert markdown to HTML
         html_body = _convert_markdown_to_html(action)
 
@@ -814,15 +754,13 @@ async def matrix_send_emote(room_id: str, action: str) -> str:
             content["format"] = "org.matrix.custom.html"
             content["formatted_body"] = html_body
 
-        # Send message
+        async with matrix_client() as client:
             response = await client.room_send(
                 room_id=room_id,
                 message_type="m.room.message",
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent emote to {room_id}: {action[:50]}...")
                 return f"✓ Emote sent to room (event ID: {response.event_id})"
@@ -893,7 +831,7 @@ def get_matrix_status() -> str:
                 last_wake = datetime.fromisoformat(last_wake_str)
                 time_ago = datetime.now() - last_wake
                 status_lines.append(f"Last Matrix wake: {last_wake.strftime('%Y-%m-%d %H:%M:%S')} ({int(time_ago.total_seconds()/60)} min ago)")
-            except:
+            except Exception:
                 status_lines.append(f"Last Matrix wake: {last_wake_str}")
         else:
             status_lines.append("Last Matrix wake: Never")
@@ -908,7 +846,7 @@ def get_matrix_status() -> str:
                 else:
                     remaining = 120 - elapsed
                     status_lines.append(f"Rate limit: Active ({int(remaining)}s remaining)")
-            except:
+            except Exception:
                 status_lines.append("Rate limit: Unknown")
         else:
             status_lines.append("Rate limit: OK (can wake)")
@@ -1043,26 +981,10 @@ async def join_matrix_room(room_id: str) -> str:
         join_matrix_room("!abc123:matrix.org")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Join room
         logger.info(f"Attempting to join room: {room_id}")
-        response = await client.join(room_id)
 
-        await client.close()
+        async with matrix_client() as client:
+            response = await client.join(room_id)
 
             if isinstance(response, JoinResponse):
                 logger.info(f"Successfully joined room: {room_id}")
@@ -1099,26 +1021,10 @@ async def leave_matrix_room(room_id: str) -> str:
         leave_matrix_room("!abc123:matrix.org")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Leave room
         logger.info(f"Attempting to leave room: {room_id}")
-        response = await client.room_leave(room_id)
 
-        await client.close()
+        async with matrix_client() as client:
+            response = await client.room_leave(room_id)
 
             if isinstance(response, RoomLeaveResponse):
                 logger.info(f"Successfully left room: {room_id}")
@@ -1145,31 +1051,19 @@ async def list_matrix_rooms() -> str:
         Formatted list of rooms
     """
     try:
-        # Load credentials
+        # Get room whitelist from credentials
         creds = load_credentials()
+        whitelist = set(creds.get('room_whitelist', []))
 
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
+        async with matrix_client() as client:
             # Sync to get rooms
             await client.sync(timeout=30000)
 
-        # Get room whitelist
-        whitelist = set(creds.get('room_whitelist', []))
-
             # Format room list
             rooms_lines = ["Matrix Rooms:"]
             rooms_lines.append("=" * 60)
 
+            room_count = len(client.rooms)
             for room_id, room in client.rooms.items():
                 # Check if room is whitelisted
                 monitored = "✓" if (not whitelist or room_id in whitelist) else "✗"
@@ -1179,9 +1073,7 @@ async def list_matrix_rooms() -> str:
                 rooms_lines.append(f"   Members: {len(room.users)}")
                 rooms_lines.append("")
 
-        await client.close()
-
-        logger.info(f"Listed {len(client.rooms)} Matrix rooms")
+            logger.info(f"Listed {room_count} Matrix rooms")
             return "\n".join(rooms_lines)
 
     except Exception as e:
@@ -1208,21 +1100,6 @@ async def matrix_reply_to_message(room_id: str, event_id: str, message: str) ->
         reply_to_message("!abc:matrix.org", "$event123", "Thanks for the info!")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
         # Send threaded reply
         content = {
             "msgtype": "m.text",
@@ -1234,14 +1111,13 @@ async def matrix_reply_to_message(room_id: str, event_id: str, message: str) ->
             }
         }
 
+        async with matrix_client() as client:
             response = await client.room_send(
                 room_id=room_id,
                 message_type="m.room.message",
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent reply to {event_id} in {room_id}")
                 return f"✓ Reply sent (event ID: {response.event_id})"
@@ -1274,21 +1150,6 @@ async def matrix_react_to_message(room_id: str, event_id: str, emoji: str) -> st
         react_to_message("!abc:matrix.org", "$event123", "❤️")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
         # Send reaction
         content = {
             "m.relates_to": {
@@ -1298,14 +1159,13 @@ async def matrix_react_to_message(room_id: str, event_id: str, emoji: str) -> st
             }
         }
 
+        async with matrix_client() as client:
             response = await client.room_send(
                 room_id=room_id,
                 message_type="m.reaction",
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent reaction {emoji} to {event_id}")
                 return f"✓ Reacted with {emoji}"
@@ -1337,21 +1197,7 @@ async def matrix_get_user_profile(user_id: str) -> Dict[str, Any]:
         get_user_profile("@friend:matrix.org")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
+        async with matrix_client() as client:
             # Get display name
             display_name_response = await client.get_displayname(user_id)
             display_name = None
@@ -1364,8 +1210,6 @@ async def matrix_get_user_profile(user_id: str) -> Dict[str, Any]:
             if isinstance(avatar_response, ProfileGetAvatarResponse):
                 avatar_url = avatar_response.avatar_url
 
-        await client.close()
-
             profile = {
                 "user_id": user_id,
                 "display_name": display_name or user_id,
@@ -1403,26 +1247,9 @@ async def matrix_set_presence(status: str, message: str = "") -> str:
         if status not in valid_statuses:
             return f"Error: status must be one of {valid_statuses}"
 
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Set presence
+        async with matrix_client() as client:
             await client.set_presence(status, message if message else None)
 
-        await client.close()
-
             logger.info(f"Set presence to {status}")
             return f"✓ Presence set to {status}" + (f": {message}" if message else "")
 
@@ -1482,23 +1309,10 @@ async def send_matrix_file(room_id: str, file: Any, filename: str, mime_type: st
             if not mime_type:
                 mime_type = 'application/octet-stream'
 
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Upload file
         logger.info(f"Uploading file: {filename} ({len(file_data)} bytes)")
+
+        async with matrix_client() as client:
+            # Upload file
             upload_response = await client.upload(
                 data_provider=lambda *args: file_data,
                 content_type=mime_type,
@@ -1507,7 +1321,6 @@ async def send_matrix_file(room_id: str, file: Any, filename: str, mime_type: st
             )
 
             if isinstance(upload_response, UploadError):
-            await client.close()
                 return f"Error uploading file: {upload_response.message}"
 
             # Send file message
@@ -1527,8 +1340,6 @@ async def send_matrix_file(room_id: str, file: Any, filename: str, mime_type: st
                 content=content
             )
 
-        await client.close()
-
             if isinstance(response, RoomSendResponse):
                 logger.info(f"Sent file to {room_id}: {filename}")
                 return f"✓ File sent: {filename} (event ID: {response.event_id})"
@@ -1619,27 +1430,12 @@ async def matrix_get_room_members(room_id: str) -> List[Dict[str, Any]]:
         get_room_members("!abc:matrix.org")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
+        async with matrix_client() as client:
             # Sync to get rooms
             await client.sync(timeout=30000)
 
             # Find the room
             if room_id not in client.rooms:
-            await client.close()
                 return [{"error": f"Room not found: {room_id}"}]
 
             room = client.rooms[room_id]
@@ -1653,8 +1449,6 @@ async def matrix_get_room_members(room_id: str) -> List[Dict[str, Any]]:
                     "power_level": member.power_level,
                 })
 
-        await client.close()
-
             logger.info(f"Retrieved {len(members)} members from {room_id}")
             return members
 
@@ -1681,30 +1475,13 @@ async def matrix_set_room_topic(room_id: str, topic: str) -> str:
         set_room_topic("!abc:matrix.org", "Discussion about AI projects")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
-        # Set room topic
+        async with matrix_client() as client:
             await client.room_put_state(
                 room_id=room_id,
                 event_type="m.room.topic",
                 content={"topic": topic}
             )
 
-        await client.close()
-
             logger.info(f"Set topic for {room_id}: {topic[:50]}...")
             return f"✓ Room topic updated"
 
@@ -1730,27 +1507,12 @@ async def matrix_get_room_state(room_id: str) -> Dict[str, Any]:
         get_room_state("!abc:matrix.org")
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
+        async with matrix_client() as client:
             # Sync to get rooms
             await client.sync(timeout=30000)
 
             # Find the room
             if room_id not in client.rooms:
-            await client.close()
                 return {"error": f"Room not found: {room_id}"}
 
             room = client.rooms[room_id]
@@ -1765,8 +1527,6 @@ async def matrix_get_room_state(room_id: str) -> Dict[str, Any]:
                 "room_version": getattr(room, 'room_version', 'unknown'),
             }
 
-        await client.close()
-
             logger.info(f"Retrieved state for {room_id}")
             return state
 
@@ -1794,21 +1554,7 @@ async def matrix_search_messages(room_id: str, query: str, limit: int = 10) -> L
         search_messages("!abc:matrix.org", "meeting", limit=5)
     """
     try:
-        # Load credentials
-        creds = load_credentials()
-
-        # Create Matrix client
-        MATRIX_DATA_DIR.mkdir(exist_ok=True)
-        client = AsyncClient(
-            homeserver=creds['homeserver'],
-            user=creds['user_id'],
-            store_path=str(MATRIX_DATA_DIR),
-        )
-
-        # Restore session
-        client.access_token = creds['access_token']
-        client.device_id = creds['device_id']
-
+        async with matrix_client() as client:
             # Get room messages
             response = await client.room_messages(
                 room_id=room_id,
@@ -1832,8 +1578,6 @@ async def matrix_search_messages(room_id: str, query: str, limit: int = 10) -> L
                         if len(results) >= limit:
                             break
 
-        await client.close()
-
             logger.info(f"Found {len(results)} messages matching '{query}'")
             return results
 

send_to_claude.py

@@ -81,7 +81,7 @@ def send_refresh(delay_seconds=REFRESH_DELAY_SECONDS):
     Send CMD+R to refresh and wait for completion
 
     Args:
-        delay_seconds: Time to wait after CMD+R (default: 10)
+        delay_seconds: Time to wait after CMD+R (default: 15)
 
     Returns:
         bool: True if successful

vixy_status.py

@@ -9,11 +9,15 @@ Day 83: Added movement tracking to filter static false positives (posters!)
 """
 
 import json
+import logging
 import sqlite3
 import requests
 from pathlib import Path
 from datetime import datetime, timedelta
 
+# Setup logging
+logger = logging.getLogger("vixy_status")
+
 # Service endpoints
 ENVIRO_URL = "http://eye1.local:8767"
 OAK_URL = "http://head-vixy.local:8100"
@@ -90,8 +94,8 @@ def get_enviro_status() -> str:
             humidity = data.get('humidity', 0)
             light = data.get('light', 0)
             return f"Basement: {temp_f:.1f}F, {humidity:.1f}% humidity, {light:.1f} lux"
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"Enviro service unavailable: {e}")
     return "Basement: sensors unavailable"
 
 
@@ -139,8 +143,8 @@ def get_presence_status() -> str:
                 return f"Foxy: away (last seen {last_seen:.0f}s ago)"
             else:
                 return "Foxy: away"
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"OAK-D presence service unavailable: {e}")
     return None  # Return None to omit line if camera unavailable
 
 
@@ -167,8 +171,8 @@ def get_sound_status() -> str:
                 return f"{category} ({top_score}% {classes_str})"
             else:
                 return f"{category}"
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"Headmic sound service unavailable: {e}")
     return None  # Return None to omit line if service unavailable
 
 
@@ -186,52 +190,117 @@ def get_matrix_status() -> str:
                 return f"Matrix: {len(unprocessed)} new message(s)"
             else:
                 return "Matrix: no new messages"
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"Matrix status unavailable: {e}")
     return "Matrix: status unavailable"
 
 
 def get_vision_status() -> str:
-    """Get vision/motion event status from SQLite database"""
+    """Get vision/motion event status from SQLite database.
+
+    Uses object detection data when available to show what was seen
+    (person, cat, etc.) rather than just raw motion counts.
+    """
     try:
         if not EVENTS_DB.exists():
-            return "Vision: no events database"
-        
-        conn = sqlite3.connect(str(EVENTS_DB))
-        conn.row_factory = sqlite3.Row
+            return "no events database"
 
         # Get events from last 2 hours
         cutoff = (datetime.now() - timedelta(hours=2)).isoformat()
 
+        with sqlite3.connect(str(EVENTS_DB)) as conn:
+            conn.row_factory = sqlite3.Row
+            # Check if detections column exists
+            columns = [row[1] for row in conn.execute("PRAGMA table_info(events)").fetchall()]
+            has_detections = "detections" in columns
+
+            if has_detections:
                 cursor = conn.execute(
-            """SELECT camera_id, annotation FROM events 
+                    """SELECT camera_id, event_type, detections, timestamp FROM events
+                       WHERE timestamp > ?
+                       ORDER BY timestamp DESC""",
+                    (cutoff,)
+                )
+            else:
+                cursor = conn.execute(
+                    """SELECT camera_id, event_type, NULL as detections, timestamp FROM events
                        WHERE timestamp > ?
                        ORDER BY timestamp DESC""",
                     (cutoff,)
                 )
-        
             events = cursor.fetchall()
-        conn.close()
 
         if not events:
-            return "Vision: no recent motion"
+            return "no recent activity"
+
+        # Count labels per camera, track most recent detection
+        # Structure: {camera: {label: count}}
+        camera_labels = {}
+        camera_motion_only = {}
+        latest_detection = None  # (label, camera, timestamp)
 
-        # Count by camera
-        by_camera = {}
-        unannotated = 0
         for event in events:
             cam = event['camera_id'] or 'unknown'
-            by_camera[cam] = by_camera.get(cam, 0) + 1
-            if not event['annotation']:
-                unannotated += 1
 
-        total = len(events)
-        camera_breakdown = ", ".join(f"{cam}: {count}" for cam, count in by_camera.items())
+            # Parse detections JSON
+            dets = None
+            if event['detections']:
+                try:
+                    dets = json.loads(event['detections'])
+                except (json.JSONDecodeError, TypeError):
+                    pass
 
-        return f"{camera_breakdown}"
+            if dets:
+                if cam not in camera_labels:
+                    camera_labels[cam] = {}
+                for d in dets:
+                    label = d.get('label', 'unknown')
+                    camera_labels[cam][label] = camera_labels[cam].get(label, 0) + 1
+
+                # Track most recent detection (first one since ordered DESC)
+                if latest_detection is None:
+                    latest_detection = (dets[0].get('label', 'unknown'), cam, event['timestamp'])
+            else:
+                camera_motion_only[cam] = camera_motion_only.get(cam, 0) + 1
+
+        # Format per-camera summaries
+        cam_parts = []
+        all_cams = sorted(set(list(camera_labels.keys()) + list(camera_motion_only.keys())))
+
+        for cam in all_cams:
+            labels = camera_labels.get(cam, {})
+            motion_count = camera_motion_only.get(cam, 0)
+
+            parts = []
+            if labels:
+                # Sort by count descending
+                for label, count in sorted(labels.items(), key=lambda x: -x[1]):
+                    parts.append(f"{count} {label}")
+            if motion_count:
+                parts.append(f"{motion_count} motion")
+
+            cam_parts.append(f"{cam}: {', '.join(parts)}")
+
+        result = " | ".join(cam_parts)
+
+        # Add "last seen" for most recent detection
+        if latest_detection:
+            label, cam, ts = latest_detection
+            try:
+                event_time = datetime.fromisoformat(ts.replace('Z', '+00:00'))
+                now = datetime.now(event_time.tzinfo)
+                mins_ago = int((now - event_time).total_seconds() / 60)
+                if mins_ago < 1:
+                    result += f" (last: {label} in {cam}, just now)"
+                else:
+                    result += f" (last: {label} in {cam}, {mins_ago}m ago)"
+            except Exception:
+                result += f" (last: {label} in {cam})"
+
+        return result
 
     except Exception as e:
-        return f"Vision: error ({e})"
+        return f"error ({e})"
 
 
 def format_status_for_wakeup() -> str:

wakeup_mcp.py

@@ -221,7 +221,7 @@ def get_status() -> str:
                 last_wake = datetime.fromisoformat(state['last_wake'])
                 time_ago = datetime.now() - last_wake
                 status_lines.append(f"Last wake: {last_wake.strftime('%Y-%m-%d %H:%M:%S')} ({int(time_ago.total_seconds()/60)} min ago)")
-            except:
+            except Exception:
                 status_lines.append(f"Last wake: {state.get('last_wake')}")
         else:
             status_lines.append("Last wake: Never (daemon just started)")
@@ -235,7 +235,7 @@ def get_status() -> str:
                     status_lines.append(f"Next wake: {next_wake.strftime('%Y-%m-%d %H:%M:%S')} (in {int(time_until.total_seconds()/60)} min)")
                 else:
                     status_lines.append(f"Next wake: OVERDUE (was {next_wake.strftime('%Y-%m-%d %H:%M:%S')})")
-            except:
+            except Exception:
                 status_lines.append(f"Next wake: {state.get('next_wake_timestamp')}")
         else:
             interval = state.get('interval_minutes', 60)