From 45f7d343c1351a930a384f618dc429aa75333960 Mon Sep 17 00:00:00 2001
From: devon7y <devon7y@gmail.com>
Date: Fri, 3 Apr 2026 13:31:26 -0600
Subject: [PATCH] Improve screen reliability and debug visibility

---
 .env.example                    |   6 +
 calendar_access.py              |  33 ++-
 frontend/index.html             |  17 ++
 frontend/src/main.ts            | 124 ++++++++++
 frontend/src/style.css          | 158 ++++++++++++
 frontend/src/ws.ts              |  16 ++
 screen.py                       | 166 +++++++++++--
 server.py                       | 413 ++++++++++++++++++++++++++------
 tests/test_calendar_access.py   |  27 +++
 tests/test_debug_log_stream.py  |  41 ++++
 tests/test_lookup_reporting.py  |  98 ++++++++
 tests/test_project_discovery.py |  62 +++++
 tests/test_screen.py            |  30 +++
 tests/test_screen_detection.py  |   9 +
 tests/test_weather.py           |  47 ++++
 15 files changed, 1157 insertions(+), 90 deletions(-)
 create mode 100644 tests/test_calendar_access.py
 create mode 100644 tests/test_debug_log_stream.py
 create mode 100644 tests/test_lookup_reporting.py
 create mode 100644 tests/test_project_discovery.py
 create mode 100644 tests/test_screen.py
 create mode 100644 tests/test_screen_detection.py
 create mode 100644 tests/test_weather.py

diff --git a/.env.example b/.env.example
index 76f8e299..3f345741 100644
--- a/.env.example
+++ b/.env.example
@@ -11,3 +11,9 @@ FISH_API_KEY=your-fish-audio-api-key-here
 # Optional: Specific Apple Calendar accounts to read (comma-separated emails)
 # If not set, JARVIS reads ALL calendars from Apple Calendar
 # CALENDAR_ACCOUNTS=you@gmail.com,work@company.com
+
+# Optional: override auto-detected weather location
+# If not set, JARVIS uses your current public-IP location and reports Celsius.
+# WEATHER_LOCATION_LABEL=Edmonton, AB
+# WEATHER_LATITUDE=53.5461
+# WEATHER_LONGITUDE=-113.4938
diff --git a/calendar_access.py b/calendar_access.py
index c91d0903..526a4f29 100644
--- a/calendar_access.py
+++ b/calendar_access.py
@@ -14,12 +14,26 @@
 
 log = logging.getLogger("jarvis.calendar")
 
+
+def _parse_calendar_accounts(raw: str) -> list[str]:
+    """Parse CALENDAR_ACCOUNTS, treating empty / auto as auto-discover."""
+    if not raw or not raw.strip():
+        return []
+    accounts = []
+    for item in raw.split(","):
+        value = item.strip()
+        if not value:
+            continue
+        if value.lower() == "auto":
+            continue
+        accounts.append(value)
+    return accounts
+
+
 # Calendars to scan — set CALENDAR_ACCOUNTS env var to a comma-separated list,
 # or leave empty to auto-discover ALL calendars from Apple Calendar.
 _calendar_accounts_env = os.getenv("CALENDAR_ACCOUNTS", "")
-USER_CALENDARS: list[str] = [
-    a.strip() for a in _calendar_accounts_env.split(",") if a.strip()
-] if _calendar_accounts_env.strip() else []
+USER_CALENDARS: list[str] = _parse_calendar_accounts(_calendar_accounts_env)
 
 _auto_discovered = False
 
@@ -181,6 +195,19 @@ async def refresh_cache():
     log.info(f"Calendar cache refreshed: {len(all_events)} events today ({elapsed:.1f}s)")
 
 
+def configure_calendar_accounts(raw: str) -> None:
+    """Apply updated calendar account settings without a server restart."""
+    global USER_CALENDARS, _auto_discovered, _event_cache, _cache_time
+    USER_CALENDARS = _parse_calendar_accounts(raw)
+    _auto_discovered = False
+    _event_cache = []
+    _cache_time = 0.0
+    if USER_CALENDARS:
+        log.info(f"Calendar accounts configured explicitly: {USER_CALENDARS}")
+    else:
+        log.info("Calendar accounts set to auto-discover")
+
+
 async def get_todays_events() -> list[dict]:
     """Get today's events from cache. Returns cached data immediately."""
     if not _event_cache and _cache_time == 0:
diff --git a/frontend/index.html b/frontend/index.html
index 9440bda4..0e877911 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -27,6 +27,7 @@
 
     <!-- Dropdown menu -->
     <div id="menu-dropdown" style="display:none">
+      <button id="btn-debug-toggle">Debug Mode</button>
       <button id="btn-settings">Settings</button>
       <button id="btn-restart">Restart Server</button>
       <button id="btn-fix-self">Fix Yourself</button>
@@ -35,6 +36,22 @@
     <div id="status-text"></div>
     <div id="jarvis-label">JARVIS</div>
     <div id="error-text"></div>
+
+    <section id="debug-panel" aria-live="polite">
+      <div id="debug-header">
+        <div>
+          <div id="debug-title">Debug Mode</div>
+          <div id="debug-connection">Disconnected</div>
+        </div>
+        <div id="debug-actions">
+          <button id="btn-debug-clear">Clear</button>
+          <button id="btn-debug-close" aria-label="Close debug panel">&times;</button>
+        </div>
+      </div>
+      <div id="debug-log">
+        <div class="debug-log-empty">Live background log will appear here.</div>
+      </div>
+    </section>
     <script type="module" src="/src/main.ts"></script>
   </body>
 </html>
diff --git a/frontend/src/main.ts b/frontend/src/main.ts
index ca5d1864..61ca3f7e 100644
--- a/frontend/src/main.ts
+++ b/frontend/src/main.ts
@@ -16,11 +16,22 @@ import "./style.css";
 // ---------------------------------------------------------------------------
 
 type State = "idle" | "listening" | "thinking" | "speaking";
+type DebugLogEntry = {
+  ts: string;
+  logger: string;
+  level: string;
+  message: string;
+};
+
 let currentState: State = "idle";
 let isMuted = false;
+let debugMode = window.localStorage.getItem("jarvis_debug_mode") === "1";
 
 const statusEl = document.getElementById("status-text")!;
 const errorEl = document.getElementById("error-text")!;
+const debugPanelEl = document.getElementById("debug-panel")!;
+const debugLogEl = document.getElementById("debug-log")!;
+const debugConnectionEl = document.getElementById("debug-connection")!;
 
 function showError(msg: string) {
   errorEl.textContent = msg;
@@ -76,6 +87,78 @@ function transition(newState: State) {
   }
 }
 
+function setDebugConnection(connected: boolean) {
+  debugConnectionEl.textContent = connected ? "Live stream connected" : "Waiting for connection...";
+}
+
+function ensureDebugPlaceholder() {
+  if (debugLogEl.childElementCount === 0) {
+    const empty = document.createElement("div");
+    empty.className = "debug-log-empty";
+    empty.textContent = "Live background log will appear here.";
+    debugLogEl.appendChild(empty);
+  }
+}
+
+function clearDebugLog() {
+  debugLogEl.innerHTML = "";
+  ensureDebugPlaceholder();
+}
+
+function appendDebugEntry(entry: DebugLogEntry) {
+  const nearBottom =
+    debugLogEl.scrollHeight - debugLogEl.scrollTop - debugLogEl.clientHeight < 40;
+
+  const empty = debugLogEl.querySelector(".debug-log-empty");
+  if (empty) empty.remove();
+
+  const row = document.createElement("div");
+  row.className = "debug-log-entry";
+
+  const timeEl = document.createElement("span");
+  timeEl.className = "debug-log-time";
+  timeEl.textContent = entry.ts;
+
+  const levelEl = document.createElement("span");
+  levelEl.className = `debug-log-level level-${entry.level.toLowerCase()}`;
+  levelEl.textContent = entry.level;
+
+  const loggerEl = document.createElement("span");
+  loggerEl.className = "debug-log-logger";
+  loggerEl.textContent = entry.logger;
+  loggerEl.title = entry.logger;
+
+  const messageEl = document.createElement("span");
+  messageEl.className = "debug-log-message";
+  messageEl.textContent = entry.message;
+
+  row.append(timeEl, levelEl, loggerEl, messageEl);
+  debugLogEl.appendChild(row);
+
+  while (debugLogEl.childElementCount > 250) {
+    debugLogEl.removeChild(debugLogEl.firstElementChild!);
+  }
+
+  if (nearBottom) {
+    debugLogEl.scrollTop = debugLogEl.scrollHeight;
+  }
+}
+
+function applyDebugMode() {
+  debugPanelEl.classList.toggle("open", debugMode);
+  btnDebugToggle.textContent = debugMode ? "Hide Debug Mode" : "Debug Mode";
+  window.localStorage.setItem("jarvis_debug_mode", debugMode ? "1" : "0");
+
+  if (!debugMode) {
+    socket.send({ type: "debug_logs", enabled: false });
+    return;
+  }
+
+  if (socket.isConnected()) {
+    socket.send({ type: "debug_logs", enabled: true });
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Voice input
 // ---------------------------------------------------------------------------
@@ -141,9 +224,28 @@ socket.onMessage((msg) => {
     console.log("[task]", "spawned:", msg.task_id, msg.prompt);
   } else if (type === "task_complete") {
     console.log("[task]", "complete:", msg.task_id, msg.status, msg.summary);
+  } else if (type === "debug_log_snapshot") {
+    clearDebugLog();
+    const entries = (msg.entries as DebugLogEntry[]) || [];
+    for (const entry of entries) appendDebugEntry(entry);
+    ensureDebugPlaceholder();
+  } else if (type === "debug_log") {
+    const entry = msg.entry as DebugLogEntry | undefined;
+    if (entry) appendDebugEntry(entry);
   }
 });
 
+socket.onOpen(() => {
+  setDebugConnection(true);
+  if (debugMode) {
+    socket.send({ type: "debug_logs", enabled: true });
+  }
+});
+
+socket.onConnectionChange((connected) => {
+  setDebugConnection(connected);
+});
+
 // ---------------------------------------------------------------------------
 // Kick off
 // ---------------------------------------------------------------------------
@@ -175,6 +277,9 @@ ensureAudioContext();
 const btnMute = document.getElementById("btn-mute")!;
 const btnMenu = document.getElementById("btn-menu")!;
 const menuDropdown = document.getElementById("menu-dropdown")!;
+const btnDebugToggle = document.getElementById("btn-debug-toggle")!;
+const btnDebugClear = document.getElementById("btn-debug-clear")!;
+const btnDebugClose = document.getElementById("btn-debug-close")!;
 const btnRestart = document.getElementById("btn-restart")!;
 const btnFixSelf = document.getElementById("btn-fix-self")!;
 
@@ -196,6 +301,22 @@ btnMenu.addEventListener("click", (e) => {
   menuDropdown.style.display = menuDropdown.style.display === "none" ? "block" : "none";
 });
 
+btnDebugToggle.addEventListener("click", (e) => {
+  e.stopPropagation();
+  menuDropdown.style.display = "none";
+  debugMode = !debugMode;
+  applyDebugMode();
+});
+
+btnDebugClear.addEventListener("click", () => {
+  clearDebugLog();
+});
+
+btnDebugClose.addEventListener("click", () => {
+  debugMode = false;
+  applyDebugMode();
+});
+
 document.addEventListener("click", () => {
   menuDropdown.style.display = "none";
 });
@@ -233,3 +354,6 @@ btnSettings.addEventListener("click", (e) => {
 setTimeout(() => {
   checkFirstTimeSetup();
 }, 2000);
+
+ensureDebugPlaceholder();
+applyDebugMode();
diff --git a/frontend/src/style.css b/frontend/src/style.css
index 899901c7..69e8fc82 100644
--- a/frontend/src/style.css
+++ b/frontend/src/style.css
@@ -130,6 +130,164 @@ html, body {
   opacity: 0;
 }
 
+#debug-panel {
+  position: fixed;
+  left: 16px;
+  right: 16px;
+  bottom: 16px;
+  height: min(38vh, 360px);
+  display: flex;
+  flex-direction: column;
+  background: rgba(4, 8, 14, 0.9);
+  border: 1px solid rgba(14, 165, 233, 0.2);
+  border-radius: 12px;
+  backdrop-filter: blur(16px);
+  box-shadow: 0 18px 60px rgba(0, 0, 0, 0.35);
+  z-index: 30;
+  opacity: 0;
+  pointer-events: none;
+  transform: translateY(16px);
+  transition: opacity 0.2s ease, transform 0.2s ease;
+}
+
+#debug-panel.open {
+  opacity: 1;
+  pointer-events: auto;
+  transform: translateY(0);
+}
+
+#debug-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 12px 14px;
+  border-bottom: 1px solid rgba(14, 165, 233, 0.12);
+}
+
+#debug-title {
+  color: rgba(125, 211, 252, 0.9);
+  font-size: 11px;
+  letter-spacing: 2px;
+  text-transform: uppercase;
+}
+
+#debug-connection {
+  margin-top: 3px;
+  color: rgba(148, 163, 184, 0.85);
+  font-size: 11px;
+  letter-spacing: 0.3px;
+}
+
+#debug-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+#debug-actions button {
+  border: 1px solid rgba(14, 165, 233, 0.18);
+  background: rgba(14, 165, 233, 0.06);
+  color: rgba(125, 211, 252, 0.78);
+  border-radius: 7px;
+  cursor: pointer;
+  transition: all 0.15s ease;
+}
+
+#debug-actions button:hover {
+  background: rgba(14, 165, 233, 0.14);
+  color: rgba(186, 230, 253, 0.96);
+  border-color: rgba(14, 165, 233, 0.32);
+}
+
+#btn-debug-clear {
+  padding: 6px 10px;
+  font-size: 11px;
+  letter-spacing: 1px;
+  text-transform: uppercase;
+}
+
+#btn-debug-close {
+  width: 30px;
+  height: 30px;
+  font-size: 18px;
+  line-height: 1;
+}
+
+#debug-log {
+  flex: 1;
+  overflow-y: auto;
+  padding: 10px 12px 14px;
+  font-family: "SFMono-Regular", "SF Mono", "Menlo", "Consolas", monospace;
+  font-size: 11px;
+  line-height: 1.45;
+  color: rgba(226, 232, 240, 0.88);
+}
+
+.debug-log-empty {
+  color: rgba(148, 163, 184, 0.75);
+  padding: 10px 8px;
+}
+
+.debug-log-entry {
+  display: grid;
+  grid-template-columns: 84px 58px minmax(0, 140px) minmax(0, 1fr);
+  gap: 10px;
+  padding: 6px 8px;
+  border-radius: 8px;
+  margin-bottom: 3px;
+  background: rgba(255, 255, 255, 0.02);
+}
+
+.debug-log-entry:hover {
+  background: rgba(14, 165, 233, 0.06);
+}
+
+.debug-log-time {
+  color: rgba(125, 211, 252, 0.9);
+}
+
+.debug-log-level {
+  text-transform: uppercase;
+  letter-spacing: 0.7px;
+  color: rgba(191, 219, 254, 0.82);
+}
+
+.debug-log-level.level-warning {
+  color: rgba(253, 224, 71, 0.9);
+}
+
+.debug-log-level.level-error,
+.debug-log-level.level-critical {
+  color: rgba(252, 165, 165, 0.94);
+}
+
+.debug-log-logger {
+  color: rgba(148, 163, 184, 0.92);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.debug-log-message {
+  color: rgba(226, 232, 240, 0.94);
+  overflow-wrap: anywhere;
+}
+
+@media (max-width: 720px) {
+  #debug-panel {
+    left: 10px;
+    right: 10px;
+    bottom: 10px;
+    height: min(46vh, 420px);
+  }
+
+  .debug-log-entry {
+    grid-template-columns: 1fr;
+    gap: 4px;
+  }
+}
+
 /* ---------------------------------------------------------------------------
    Settings Panel
    --------------------------------------------------------------------------- */
diff --git a/frontend/src/ws.ts b/frontend/src/ws.ts
index f7b2b4ae..54f8f3b1 100644
--- a/frontend/src/ws.ts
+++ b/frontend/src/ws.ts
@@ -3,10 +3,13 @@
  */
 
 export type MessageHandler = (msg: Record<string, unknown>) => void;
+export type ConnectionHandler = (connected: boolean) => void;
 
 export interface JarvisSocket {
   send(data: Record<string, unknown>): void;
   onMessage(handler: MessageHandler): void;
+  onOpen(handler: ConnectionHandler): void;
+  onConnectionChange(handler: ConnectionHandler): void;
   close(): void;
   isConnected(): boolean;
 }
@@ -14,6 +17,8 @@ export interface JarvisSocket {
 export function createSocket(url: string): JarvisSocket {
   let ws: WebSocket | null = null;
   let handlers: MessageHandler[] = [];
+  let openHandlers: ConnectionHandler[] = [];
+  let connectionHandlers: ConnectionHandler[] = [];
   let reconnectDelay = 1000;
   let closed = false;
   let connected = false;
@@ -27,6 +32,8 @@ export function createSocket(url: string): JarvisSocket {
       connected = true;
       reconnectDelay = 1000;
       console.log("[ws] connected");
+      for (const h of openHandlers) h(true);
+      for (const h of connectionHandlers) h(true);
     };
 
     ws.onmessage = (event) => {
@@ -40,6 +47,7 @@ export function createSocket(url: string): JarvisSocket {
 
     ws.onclose = () => {
       connected = false;
+      for (const h of connectionHandlers) h(false);
       if (!closed) {
         console.log(`[ws] reconnecting in ${reconnectDelay}ms`);
         setTimeout(connect, reconnectDelay);
@@ -64,6 +72,14 @@ export function createSocket(url: string): JarvisSocket {
     onMessage(handler) {
       handlers.push(handler);
     },
+    onOpen(handler) {
+      openHandlers.push(handler);
+      if (connected) handler(true);
+    },
+    onConnectionChange(handler) {
+      connectionHandlers.push(handler);
+      handler(connected);
+    },
     close() {
       closed = true;
       ws?.close();
diff --git a/screen.py b/screen.py
index 343dda4a..6ea781e7 100644
--- a/screen.py
+++ b/screen.py
@@ -8,13 +8,24 @@
 
 import asyncio
 import base64
-import json
 import logging
 import tempfile
 from pathlib import Path
 
 log = logging.getLogger("jarvis.screen")
 
+VISION_MAX_IMAGE_BYTES = 5 * 1024 * 1024
+VISION_TARGET_IMAGE_BYTES = int(VISION_MAX_IMAGE_BYTES * 0.9)
+VISION_REDUCTION_STEPS = [
+    (None, 99),
+    (None, 95),
+    (None, 90),
+    (3200, 90),
+    (2800, 90),
+    (2400, 85),
+    (2200, 75),
+]
+
 
 async def get_active_windows() -> list[dict]:
     """Get list of visible windows with app name, window title, and position.
@@ -105,18 +116,114 @@ async def get_running_apps() -> list[str]:
         return []
 
 
-async def take_screenshot(display_only: bool = True) -> str | None:
-    """Take a screenshot and return base64-encoded PNG.
+def _media_type_for_path(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix in {".jpg", ".jpeg"}:
+        return "image/jpeg"
+    if suffix == ".png":
+        return "image/png"
+    if suffix == ".gif":
+        return "image/gif"
+    return "application/octet-stream"
+
+
+async def _run_image_transform(input_path: Path, output_path: Path, max_pixels: int | None, quality: int) -> bool:
+    cmd = [
+        "sips",
+        "-s", "format", "jpeg",
+        "-s", "formatOptions", str(quality),
+    ]
+    if max_pixels is not None:
+        cmd.extend(["-Z", str(max_pixels)])
+    cmd.extend([
+        str(input_path),
+        "--out", str(output_path),
+    ])
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=15)
+    if proc.returncode != 0 or not output_path.exists():
+        log.warning(
+            "Image compression failed: quality=%s max_pixels=%s stdout=%s stderr=%s",
+            quality,
+            max_pixels if max_pixels is not None else "full",
+            stdout.decode(errors="replace")[:200],
+            stderr.decode(errors="replace")[:200],
+        )
+        return False
+    return True
+
+
+async def _prepare_image_for_vision(image_path: Path) -> Path | None:
+    """Shrink large screenshots until they fit within the Anthropic image limit."""
+    if not image_path.exists():
+        return None
+
+    try:
+        original_size = image_path.stat().st_size
+    except Exception:
+        return image_path
+
+    if original_size <= VISION_TARGET_IMAGE_BYTES:
+        return image_path
+
+    candidate_path = image_path.with_name(f"{image_path.stem}.vision.jpg")
+    smallest_path = image_path
+    smallest_size = original_size
+
+    for max_pixels, quality in VISION_REDUCTION_STEPS:
+        if not await _run_image_transform(image_path, candidate_path, max_pixels, quality):
+            continue
+
+        try:
+            candidate_size = candidate_path.stat().st_size
+        except Exception:
+            continue
+
+        if candidate_size < smallest_size:
+            smallest_path = candidate_path
+            smallest_size = candidate_size
+
+        if candidate_size <= VISION_TARGET_IMAGE_BYTES:
+            log.info(
+                "Compressed screenshot for vision: %s -> %s bytes (%s @ q%s)",
+                original_size,
+                candidate_size,
+                f"{max_pixels}px" if max_pixels is not None else "full-res",
+                quality,
+            )
+            return candidate_path
+
+    if smallest_size < original_size:
+        log.warning(
+            "Screenshot still large after compression: %s -> %s bytes; sending smallest version",
+            original_size,
+            smallest_size,
+        )
+        return smallest_path
+
+    return image_path
+
+
+async def take_screenshot(display_only: bool = True) -> tuple[str, str] | None:
+    """Take a screenshot and return base64 image data plus media type.
 
     Args:
         display_only: If True, capture main display only. If False, all displays.
 
     Returns:
-        Base64-encoded PNG string, or None on failure.
+        Tuple of (base64 image data, media type), or None on failure.
     """
     with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
         tmp_path = f.name
 
+    tmp_file = Path(tmp_path)
+    final_path = tmp_file
+
     try:
         cmd = ["screencapture", "-x"]  # -x = no sound
         if display_only:
@@ -128,15 +235,35 @@ async def take_screenshot(display_only: bool = True) -> str | None:
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
-        await asyncio.wait_for(proc.communicate(), timeout=10)
+        _, stderr = await asyncio.wait_for(proc.communicate(), timeout=10)
 
-        if proc.returncode != 0 or not Path(tmp_path).exists():
-            log.warning("Screenshot capture failed")
+        if proc.returncode != 0 or not final_path.exists():
+            log.warning(
+                "Screenshot capture failed: returncode=%s stderr=%s",
+                proc.returncode,
+                stderr.decode(errors="replace")[:200],
+            )
+            return None
+
+        optimized_path = await _prepare_image_for_vision(final_path)
+        if optimized_path:
+            final_path = optimized_path
+
+        data = final_path.read_bytes()
+        if len(data) > VISION_MAX_IMAGE_BYTES:
+            log.warning(
+                "Prepared screenshot still exceeds vision limit: %s bytes (%s)",
+                len(data),
+                final_path.name,
+            )
             return None
 
-        data = Path(tmp_path).read_bytes()
-        log.info(f"Screenshot captured: {len(data)} bytes")
-        return base64.b64encode(data).decode()
+        log.info(
+            "Screenshot captured for vision: %s bytes (%s)",
+            len(data),
+            final_path.suffix.lower().lstrip(".") or "bin",
+        )
+        return base64.b64encode(data).decode(), _media_type_for_path(final_path)
 
     except asyncio.TimeoutError:
         log.warning("Screenshot timed out")
@@ -146,7 +273,9 @@ async def take_screenshot(display_only: bool = True) -> str | None:
         return None
     finally:
         try:
-            Path(tmp_path).unlink(missing_ok=True)
+            tmp_file.unlink(missing_ok=True)
+            if final_path != tmp_file:
+                final_path.unlink(missing_ok=True)
         except Exception:
             pass
 
@@ -157,17 +286,20 @@ async def describe_screen(anthropic_client) -> str:
     Tries screenshot + vision first. Falls back to window list + LLM summary.
     """
     # Try screenshot + vision
-    screenshot_b64 = await take_screenshot()
-    if screenshot_b64 and anthropic_client:
+    screenshot = await take_screenshot()
+    if screenshot and anthropic_client:
+        screenshot_b64, media_type = screenshot
         try:
             response = await anthropic_client.messages.create(
                 model="claude-haiku-4-5-20251001",
                 max_tokens=300,
                 system=(
                     "You are JARVIS analyzing a screenshot of the user's desktop. "
-                    "Describe what you see concisely: which apps are open, what the user "
-                    "appears to be working on, any notable content visible. "
-                    "Be specific about app names, file names, URLs, code, or documents visible. "
+                    "Describe what you see concisely: what the user appears to be working on, "
+                    "which window is most important, and any notable visible content. "
+                    "Focus on readable on-screen text, terminal output, editor text, document titles, "
+                    "URLs, filenames, code, or spreadsheet content when legible. "
+                    "Do not just list apps unless the text is unreadable. "
                     "2-4 sentences max. No markdown."
                 ),
                 messages=[{
@@ -177,7 +309,7 @@ async def describe_screen(anthropic_client) -> str:
                             "type": "image",
                             "source": {
                                 "type": "base64",
-                                "media_type": "image/png",
+                                "media_type": media_type,
                                 "data": screenshot_b64,
                             },
                         },
diff --git a/server.py b/server.py
index acabce27..41f54379 100644
--- a/server.py
+++ b/server.py
@@ -15,6 +15,8 @@
 import os
 import sys
 import time
+import threading
+from collections import deque
 from pathlib import Path
 
 # Load .env file if present
@@ -42,7 +44,15 @@
 from actions import execute_action, monitor_build, open_terminal, open_browser, open_claude_in_project, _generate_project_name, prompt_existing_terminal
 from work_mode import WorkSession, is_casual_question
 from screen import get_active_windows, take_screenshot, describe_screen, format_windows_for_context
-from calendar_access import get_todays_events, get_upcoming_events, get_next_event, format_events_for_context, format_schedule_summary, refresh_cache as refresh_calendar_cache
+from calendar_access import (
+    get_todays_events,
+    get_upcoming_events,
+    get_next_event,
+    format_events_for_context,
+    format_schedule_summary,
+    refresh_cache as refresh_calendar_cache,
+    configure_calendar_accounts,
+)
 from mail_access import get_unread_count, get_unread_messages, get_recent_messages, search_mail, read_message, format_unread_summary, format_messages_for_context, format_messages_for_voice
 from memory import (
     remember, recall, get_open_tasks, create_task, complete_task, search_tasks,
@@ -56,6 +66,79 @@
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(name)s] %(message)s")
 log = logging.getLogger("jarvis")
 
+
+class DebugLogStream:
+    """Keeps a recent log buffer and pushes live log entries to subscribed sockets."""
+
+    def __init__(self, max_entries: int = 300):
+        self._entries = deque(maxlen=max_entries)
+        self._subscribers: set[WebSocket] = set()
+        self._lock = threading.Lock()
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def set_loop(self, loop: asyncio.AbstractEventLoop):
+        self._loop = loop
+
+    def publish(self, record: logging.LogRecord):
+        entry = {
+            "ts": datetime.fromtimestamp(record.created).strftime("%H:%M:%S.%f")[:-3],
+            "logger": record.name,
+            "level": record.levelname,
+            "message": record.getMessage(),
+        }
+        with self._lock:
+            self._entries.append(entry)
+
+        if not self._subscribers:
+            return
+
+        loop = self._loop
+        if not loop or loop.is_closed():
+            return
+
+        try:
+            loop.call_soon_threadsafe(self._schedule_broadcast, {"type": "debug_log", "entry": entry})
+        except RuntimeError:
+            pass
+
+    def _schedule_broadcast(self, message: dict):
+        asyncio.create_task(self._broadcast(message))
+
+    async def _broadcast(self, message: dict):
+        dead = []
+        for ws in list(self._subscribers):
+            try:
+                await ws.send_json(message)
+            except Exception:
+                dead.append(ws)
+        for ws in dead:
+            self._subscribers.discard(ws)
+
+    def snapshot(self) -> list[dict]:
+        with self._lock:
+            return list(self._entries)
+
+    async def subscribe(self, ws: WebSocket):
+        self._subscribers.add(ws)
+        await ws.send_json({"type": "debug_log_snapshot", "entries": self.snapshot()})
+
+    def unsubscribe(self, ws: WebSocket):
+        self._subscribers.discard(ws)
+
+
+class _DebugLogHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord):
+        try:
+            debug_log_stream.publish(record)
+        except Exception:
+            pass
+
+
+debug_log_stream = DebugLogStream()
+_debug_log_handler = _DebugLogHandler(level=logging.INFO)
+if not any(isinstance(handler, _DebugLogHandler) for handler in logging.getLogger().handlers):
+    logging.getLogger().addHandler(_debug_log_handler)
+
 # ---------------------------------------------------------------------------
 # Config
 # ---------------------------------------------------------------------------
@@ -68,6 +151,14 @@
 PROJECT_DIR = os.path.dirname(os.path.abspath(__file__))
 
 DESKTOP_PATH = Path.home() / "Desktop"
+REPO_ROOT = Path(PROJECT_DIR).resolve()
+PROJECT_SCAN_ROOTS = [
+    DESKTOP_PATH,
+    Path.home() / "VS_Code",
+    Path.home() / "Code",
+    Path.home() / "Projects",
+    Path.home() / "Developer",
+]
 
 JARVIS_SYSTEM_PROMPT = """\
 You are JARVIS — Just A Rather Very Intelligent System. You serve as {user_name}'s AI assistant, modeled precisely after Tony Stark's AI from the MCU films.
@@ -239,29 +330,113 @@
 
 
 # ---------------------------------------------------------------------------
-# Weather (wttr.in)
+# Weather
 # ---------------------------------------------------------------------------
 
 _cached_weather: Optional[str] = None
 _weather_fetched: bool = False
+_cached_weather_location: Optional[dict] = None
+_weather_location_fetched_at: float = 0.0
+_WEATHER_LOCATION_TTL_SECONDS = 60 * 15
+
+
+def _format_location_label(city: str, region: str, country: str) -> str:
+    parts = [part.strip() for part in (city, region) if part and part.strip()]
+    if parts:
+        return ", ".join(parts[:2])
+    return (country or "your area").strip() or "your area"
+
+
+def _get_weather_location() -> Optional[dict]:
+    """Resolve the user's current weather location, with env overrides."""
+    global _cached_weather_location, _weather_location_fetched_at
+
+    lat_raw = os.getenv("WEATHER_LATITUDE", "").strip()
+    lon_raw = os.getenv("WEATHER_LONGITUDE", "").strip()
+    label_override = os.getenv("WEATHER_LOCATION_LABEL", "").strip()
+    if lat_raw and lon_raw:
+        try:
+            return {
+                "latitude": float(lat_raw),
+                "longitude": float(lon_raw),
+                "label": label_override or "your area",
+            }
+        except ValueError:
+            log.warning("Invalid WEATHER_LATITUDE / WEATHER_LONGITUDE in environment")
+
+    if (
+        _cached_weather_location is not None
+        and (time.time() - _weather_location_fetched_at) < _WEATHER_LOCATION_TTL_SECONDS
+    ):
+        return _cached_weather_location
+
+    try:
+        import urllib.request
+
+        with urllib.request.urlopen(
+            "https://ipwho.is/?fields=success,city,region,country,latitude,longitude",
+            timeout=3,
+        ) as resp:
+            data = json.loads(resp.read().decode())
+
+        if data.get("success") is True:
+            location = {
+                "latitude": float(data["latitude"]),
+                "longitude": float(data["longitude"]),
+                "label": label_override or _format_location_label(
+                    str(data.get("city", "")),
+                    str(data.get("region", "")),
+                    str(data.get("country", "")),
+                ),
+            }
+            _cached_weather_location = location
+            _weather_location_fetched_at = time.time()
+            return location
+    except Exception as e:
+        log.debug(f"Weather location lookup failed: {e}")
+
+    return _cached_weather_location
+
+
+def _fetch_weather_sync() -> str:
+    """Fetch current weather in Celsius for the resolved location."""
+    location = _get_weather_location()
+    if not location:
+        return "Weather data unavailable."
+
+    try:
+        import urllib.request
+
+        lat = location["latitude"]
+        lon = location["longitude"]
+        url = (
+            "https://api.open-meteo.com/v1/forecast"
+            f"?latitude={lat}&longitude={lon}"
+            "&current=temperature_2m"
+            "&temperature_unit=celsius"
+        )
+        with urllib.request.urlopen(url, timeout=3) as resp:
+            current = json.loads(resp.read().decode()).get("current", {})
+        temp = current.get("temperature_2m")
+        if temp is None:
+            return "Weather data unavailable."
+
+        temp_num = float(temp)
+        temp_text = f"{temp_num:.1f}".rstrip("0").rstrip(".")
+        return f"Current weather in {location['label']}: {temp_text}°C"
+    except Exception as e:
+        log.warning(f"Weather fetch failed: {e}")
+        return "Weather data unavailable."
 
 
 async def fetch_weather() -> str:
-    """Fetch current weather from wttr.in. Cached for the session."""
+    """Fetch current weather from the resolved location. Cached for the session."""
     global _cached_weather, _weather_fetched
     if _weather_fetched:
         return _cached_weather or "Weather data unavailable."
     _weather_fetched = True
-    try:
-        async with httpx.AsyncClient(timeout=5.0) as http:
-            resp = await http.get("https://wttr.in/?format=%l:+%C,+%t", headers={"User-Agent": "curl"})
-            if resp.status_code == 200:
-                _cached_weather = resp.text.strip()
-                return _cached_weather
-    except Exception as e:
-        log.warning(f"Weather fetch failed: {e}")
-    _cached_weather = None
-    return "Weather data unavailable."
+    _cached_weather = _fetch_weather_sync()
+    return _cached_weather
 
 
 # ---------------------------------------------------------------------------
@@ -564,42 +739,91 @@ def get_active_tasks_summary(self) -> str:
 # ---------------------------------------------------------------------------
 
 async def scan_projects() -> list[dict]:
-    """Quick scan of ~/Desktop for git repos (depth 1)."""
-    projects = []
-    desktop = DESKTOP_PATH
+    """Quick scan of common local project roots for git repos."""
+    return _collect_local_projects()
+
+
+def _git_head_file(repo_dir: Path) -> Path | None:
+    """Resolve the HEAD file for a repo, including worktree-style .git files."""
+    git_path = repo_dir / ".git"
+    if git_path.is_dir():
+        return git_path / "HEAD"
+    if git_path.is_file():
+        try:
+            raw = git_path.read_text().strip()
+            if raw.startswith("gitdir:"):
+                git_dir = raw.split(":", 1)[1].strip()
+                resolved = Path(git_dir)
+                if not resolved.is_absolute():
+                    resolved = (repo_dir / git_dir).resolve()
+                return resolved / "HEAD"
+        except Exception:
+            return None
+    return None
+
 
-    if not desktop.exists():
-        return projects
+def _read_git_branch(repo_dir: Path) -> str:
+    head_file = _git_head_file(repo_dir)
+    if not head_file or not head_file.exists():
+        return "unknown"
 
     try:
-        for entry in sorted(desktop.iterdir()):
-            if not entry.is_dir() or entry.name.startswith("."):
-                continue
-            git_dir = entry / ".git"
-            if git_dir.exists():
-                branch = "unknown"
-                head_file = git_dir / "HEAD"
-                try:
-                    head_content = head_file.read_text().strip()
-                    if head_content.startswith("ref: refs/heads/"):
-                        branch = head_content.replace("ref: refs/heads/", "")
-                except Exception:
-                    pass
+        head_content = head_file.read_text().strip()
+    except Exception:
+        return "unknown"
 
-                projects.append({
-                    "name": entry.name,
-                    "path": str(entry),
-                    "branch": branch,
-                })
-    except PermissionError:
-        pass
+    if head_content.startswith("ref: refs/heads/"):
+        return head_content.replace("ref: refs/heads/", "")
+
+    return "detached"
+
+
+def _append_project_record(projects: list[dict], seen_paths: set[str], entry: Path):
+    """Add a repo to the project list if it looks like a top-level project."""
+    try:
+        resolved = entry.resolve()
+    except Exception:
+        resolved = entry
+
+    if not resolved.is_dir() or resolved.name.startswith("."):
+        return
+    if not (resolved / ".git").exists():
+        return
+
+    path = str(resolved)
+    if path in seen_paths:
+        return
+
+    seen_paths.add(path)
+    projects.append({
+        "name": resolved.name,
+        "path": path,
+        "branch": _read_git_branch(resolved),
+    })
+
+
+def _collect_local_projects() -> list[dict]:
+    """Scan common local project roots plus the current repo."""
+    projects: list[dict] = []
+    seen_paths: set[str] = set()
+
+    _append_project_record(projects, seen_paths, REPO_ROOT)
+
+    for root in PROJECT_SCAN_ROOTS:
+        if not root.exists():
+            continue
+        try:
+            for entry in sorted(root.iterdir()):
+                _append_project_record(projects, seen_paths, entry)
+        except (FileNotFoundError, NotADirectoryError, PermissionError):
+            continue
 
     return projects
 
 
 def format_projects_for_prompt(projects: list[dict]) -> str:
     if not projects:
-        return "No projects found on Desktop."
+        return "No local projects found."
     lines = []
     for p in projects:
         lines.append(f"- {p['name']} ({p['branch']}) @ {p['path']}")
@@ -876,14 +1100,47 @@ async def _execute_open_terminal():
 
 
 def _find_project_dir(project_name: str) -> str | None:
-    """Find a project directory by name from cached projects or Desktop."""
-    for p in cached_projects:
-        if project_name.lower() in p.get("name", "").lower():
-            return p.get("path")
-    desktop = Path.home() / "Desktop"
-    for d in desktop.iterdir():
-        if d.is_dir() and project_name.lower() in d.name.lower():
-            return str(d)
+    """Find a project directory by name from scanned projects or recent dispatches."""
+    target = project_name.strip().lower()
+    if not target:
+        return None
+
+    def _match_project(projects: list[dict]) -> str | None:
+        exact_matches: list[str] = []
+        fuzzy_matches: list[str] = []
+
+        for project in projects:
+            path = project.get("path")
+            if not path or not Path(path).exists():
+                continue
+
+            name = project.get("name", "").strip().lower()
+            basename = Path(path).name.lower()
+
+            if target in {name, basename}:
+                exact_matches.append(path)
+                continue
+
+            if target in name or target in basename or name in target or basename in target:
+                fuzzy_matches.append(path)
+
+        if exact_matches:
+            return exact_matches[0]
+        if fuzzy_matches:
+            return fuzzy_matches[0]
+        return None
+
+    scanned_projects = [*cached_projects, *_scan_projects_sync()]
+    matched = _match_project(scanned_projects)
+    if matched:
+        return matched
+
+    dispatch = dispatch_registry.get_by_name(project_name)
+    if dispatch:
+        path = dispatch.get("project_path")
+        if path and Path(path).exists():
+            return path
+
     return None
 
 
@@ -1318,12 +1575,7 @@ def _worker():
 
             # Weather — refresh every loop (30s is fine, API is fast)
             try:
-                import urllib.request, json as _json
-                url = "https://api.open-meteo.com/v1/forecast?latitude=27.77&longitude=-82.64&current=temperature_2m,weathercode&temperature_unit=fahrenheit"
-                with urllib.request.urlopen(url, timeout=3) as resp:
-                    d = _json.loads(resp.read()).get("current", {})
-                    temp = d.get("temperature_2m", "?")
-                    _ctx_cache["weather"] = f"Current weather in St. Petersburg, FL: {temp}°F"
+                _ctx_cache["weather"] = _fetch_weather_sync()
             except Exception:
                 pass
 
@@ -1337,6 +1589,7 @@ def _worker():
 @asynccontextmanager
 async def lifespan(application: FastAPI):
     global anthropic_client, cached_projects
+    debug_log_stream.set_loop(asyncio.get_running_loop())
     if ANTHROPIC_API_KEY:
         anthropic_client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
     else:
@@ -1437,16 +1690,8 @@ async def api_list_projects():
 # -- Fast Action Detection (no LLM call) -----------------------------------
 
 def _scan_projects_sync() -> list[dict]:
-    """Synchronous Desktop scan — runs in executor."""
-    projects = []
-    desktop = Path.home() / "Desktop"
-    try:
-        for entry in desktop.iterdir():
-            if entry.is_dir() and not entry.name.startswith("."):
-                projects.append({"name": entry.name, "path": str(entry), "branch": ""})
-    except Exception:
-        pass
-    return projects
+    """Synchronous local project scan — runs in executor."""
+    return _collect_local_projects()
 
 
 def detect_action_fast(text: str) -> dict | None:
@@ -1464,7 +1709,9 @@ def detect_action_fast(text: str) -> dict | None:
 
     # Screen requests — checked BEFORE project matching to prevent misrouting
     if any(p in t for p in ["look at my screen", "what's on my screen", "whats on my screen",
-                             "what am i looking at", "what do you see", "see my screen",
+                             "what is on my screen", "what's on the screen", "what is on the screen",
+                             "whats on the screen", "tell me what's on my screen",
+                             "tell me what is on my screen", "what am i looking at", "what do you see", "see my screen",
                              "what's running on my", "whats running on my", "check my screen"]):
         return {"action": "describe_screen"}
 
@@ -1477,7 +1724,9 @@ def detect_action_fast(text: str) -> dict | None:
         return {"action": "show_recent"}
 
     # Screen awareness — explicit look/see requests
-    if any(p in t for p in ["what's on my screen", "whats on my screen", "what do you see",
+    if any(p in t for p in ["what's on my screen", "whats on my screen", "what is on my screen",
+                             "what's on the screen", "what is on the screen", "whats on the screen",
+                             "tell me what's on my screen", "tell me what is on my screen", "what do you see",
                              "can you see my screen", "look at my screen", "what am i looking at",
                              "what's open", "whats open", "what apps are open"]):
         return {"action": "describe_screen"}
@@ -1586,6 +1835,7 @@ async def handle_show_recent() -> str:
 
 # Track active lookups so JARVIS can report status
 _active_lookups: dict[str, dict] = {}  # id -> {"type": str, "status": str, "started": float}
+_latest_lookup_by_type: dict[str, str] = {}
 
 
 async def _lookup_and_report(lookup_type: str, lookup_fn, ws, history: list[dict] = None, voice_state: dict = None):
@@ -1599,6 +1849,7 @@ async def _lookup_and_report(lookup_type: str, lookup_fn, ws, history: list[dict
         "status": "working",
         "started": time.time(),
     }
+    _latest_lookup_by_type[lookup_type] = lookup_id
 
     try:
         # Run the async lookup directly — these functions already use
@@ -1610,6 +1861,10 @@ async def _lookup_and_report(lookup_type: str, lookup_fn, ws, history: list[dict
 
         _active_lookups[lookup_id]["status"] = "done"
 
+        if _latest_lookup_by_type.get(lookup_type) != lookup_id:
+            log.info(f"Discarding stale {lookup_type} lookup #{lookup_id}")
+            return
+
         # Speak the result — skip audio if user spoke recently to avoid collision
         if voice_state and time.time() - voice_state["last_user_time"] < 3:
             log.info(f"Skipping lookup audio for {lookup_type} — user spoke recently")
@@ -1620,14 +1875,14 @@ async def _lookup_and_report(lookup_type: str, lookup_fn, ws, history: list[dict
             try:
                 await ws.send_json({"type": "status", "state": "speaking"})
                 if audio:
-                    await ws.send_json({"type": "audio", "data": audio, "text": result_text})
+                    await ws.send_json({"type": "audio", "data": base64.b64encode(audio).decode(), "text": result_text})
                 else:
                     await ws.send_json({"type": "text", "text": result_text})
                 await ws.send_json({"type": "status", "state": "idle"})
             except Exception:
                 pass
 
-        log.info(f"Lookup {lookup_type} complete: {result_text[:80]}")
+        log.info(f"Lookup {lookup_type} complete: {result_text}")
 
         # Store lookup result in conversation history so JARVIS remembers it
         if history is not None:
@@ -1635,12 +1890,15 @@ async def _lookup_and_report(lookup_type: str, lookup_fn, ws, history: list[dict
 
     except asyncio.TimeoutError:
         _active_lookups[lookup_id]["status"] = "timeout"
+        if _latest_lookup_by_type.get(lookup_type) != lookup_id:
+            log.info(f"Discarding stale timeout for {lookup_type} lookup #{lookup_id}")
+            return
         try:
             fallback = f"That {lookup_type} check is taking too long, sir. The data may still be syncing."
             audio = await synthesize_speech(fallback)
             await ws.send_json({"type": "status", "state": "speaking"})
             if audio:
-                await ws.send_json({"type": "audio", "data": audio, "text": fallback})
+                await ws.send_json({"type": "audio", "data": base64.b64encode(audio).decode(), "text": fallback})
             await ws.send_json({"type": "status", "state": "idle"})
         except Exception:
             pass
@@ -1651,6 +1909,8 @@ async def _lookup_and_report(lookup_type: str, lookup_fn, ws, history: list[dict
         # Clean up after 60s
         await asyncio.sleep(60)
         _active_lookups.pop(lookup_id, None)
+        if _latest_lookup_by_type.get(lookup_type) == lookup_id:
+            _latest_lookup_by_type.pop(lookup_type, None)
 
 
 async def _do_calendar_lookup() -> str:
@@ -1865,12 +2125,15 @@ async def voice_handler(ws: WebSocket):
 
     Client -> Server:
         {"type": "transcript", "text": "...", "isFinal": true}
+        {"type": "debug_logs", "enabled": true|false}
 
     Server -> Client:
         {"type": "audio", "data": "<base64 mp3>", "text": "spoken text"}
         {"type": "status", "state": "thinking"|"speaking"|"idle"|"working"}
         {"type": "task_spawned", "task_id": "...", "prompt": "..."}
         {"type": "task_complete", "task_id": "...", "summary": "..."}
+        {"type": "debug_log_snapshot", "entries": [...]}
+        {"type": "debug_log", "entry": {...}}
     """
     await ws.accept()
     task_manager.register_websocket(ws)
@@ -1949,11 +2212,18 @@ async def _send_greeting():
                 await ws.send_json({"type": "status", "state": "speaking"})
                 audio = await synthesize_speech(tts)
                 if audio:
-                    await ws.send_json({"type": "audio", "data": audio, "text": response_text})
+                    await ws.send_json({"type": "audio", "data": base64.b64encode(audio).decode(), "text": response_text})
                 else:
                     await ws.send_json({"type": "text", "text": response_text})
                 continue
 
+            if msg.get("type") == "debug_logs":
+                if msg.get("enabled"):
+                    await debug_log_stream.subscribe(ws)
+                else:
+                    debug_log_stream.unsubscribe(ws)
+                continue
+
             if msg.get("type") != "transcript" or not msg.get("isFinal"):
                 continue
 
@@ -2348,6 +2618,7 @@ async def _do_summary():
     except Exception as e:
         log.error(f"WebSocket error: {e}", exc_info=True)
     finally:
+        debug_log_stream.unsubscribe(ws)
         task_manager.unregister_websocket(ws)
 
 
@@ -2497,9 +2768,11 @@ async def api_get_preferences():
 
 @app.post("/api/settings/preferences")
 async def api_save_preferences(body: PreferencesUpdate):
+    normalized_calendar_accounts = body.calendar_accounts.strip() or "auto"
     _write_env_key("USER_NAME", body.user_name)
     _write_env_key("HONORIFIC", body.honorific)
-    _write_env_key("CALENDAR_ACCOUNTS", body.calendar_accounts)
+    _write_env_key("CALENDAR_ACCOUNTS", normalized_calendar_accounts)
+    configure_calendar_accounts(normalized_calendar_accounts)
     return {"success": True}
 
 # ---------------------------------------------------------------------------
diff --git a/tests/test_calendar_access.py b/tests/test_calendar_access.py
new file mode 100644
index 00000000..6f258061
--- /dev/null
+++ b/tests/test_calendar_access.py
@@ -0,0 +1,27 @@
+import calendar_access
+
+
+def test_parse_calendar_accounts_treats_auto_as_empty():
+    assert calendar_access._parse_calendar_accounts("auto") == []
+    assert calendar_access._parse_calendar_accounts(" AUTO ") == []
+
+
+def test_parse_calendar_accounts_keeps_named_calendars():
+    assert calendar_access._parse_calendar_accounts("Work, Personal") == [
+        "Work",
+        "Personal",
+    ]
+
+
+def test_configure_calendar_accounts_resets_auto_discovery_state():
+    calendar_access.USER_CALENDARS = ["Old"]
+    calendar_access._auto_discovered = True
+    calendar_access._event_cache = [{"title": "Old event"}]
+    calendar_access._cache_time = 123.0
+
+    calendar_access.configure_calendar_accounts("auto")
+
+    assert calendar_access.USER_CALENDARS == []
+    assert calendar_access._auto_discovered is False
+    assert calendar_access._event_cache == []
+    assert calendar_access._cache_time == 0.0
diff --git a/tests/test_debug_log_stream.py b/tests/test_debug_log_stream.py
new file mode 100644
index 00000000..cc4946fb
--- /dev/null
+++ b/tests/test_debug_log_stream.py
@@ -0,0 +1,41 @@
+import asyncio
+import logging
+
+import server
+
+
+class _FakeWS:
+    def __init__(self):
+        self.messages = []
+
+    async def send_json(self, payload):
+        self.messages.append(payload)
+
+
+def test_debug_log_stream_sends_snapshot_and_live_entries():
+    ws = _FakeWS()
+    stream = server.DebugLogStream(max_entries=10)
+
+    async def run_test():
+        stream.set_loop(asyncio.get_running_loop())
+        await stream.subscribe(ws)
+
+        record = logging.LogRecord(
+            name="jarvis.debug",
+            level=logging.INFO,
+            pathname=__file__,
+            lineno=1,
+            msg="live test message",
+            args=(),
+            exc_info=None,
+        )
+        stream.publish(record)
+        await asyncio.sleep(0)
+
+    asyncio.run(run_test())
+
+    assert ws.messages[0]["type"] == "debug_log_snapshot"
+    assert ws.messages[0]["entries"] == []
+    assert ws.messages[1]["type"] == "debug_log"
+    assert ws.messages[1]["entry"]["logger"] == "jarvis.debug"
+    assert ws.messages[1]["entry"]["message"] == "live test message"
diff --git a/tests/test_lookup_reporting.py b/tests/test_lookup_reporting.py
new file mode 100644
index 00000000..be90bc97
--- /dev/null
+++ b/tests/test_lookup_reporting.py
@@ -0,0 +1,98 @@
+import asyncio
+import logging
+
+import server
+
+
+class _FakeWS:
+    def __init__(self):
+        self.messages = []
+
+    async def send_json(self, payload):
+        self.messages.append(payload)
+
+
+def test_lookup_and_report_discards_stale_results(monkeypatch):
+    real_sleep = asyncio.sleep
+    ws = _FakeWS()
+
+    async def no_audio(_text):
+        return None
+
+    async def fast_sleep(_delay):
+        await real_sleep(0)
+
+    async def slow_lookup():
+        await real_sleep(0.02)
+        return "old result"
+
+    async def fast_lookup():
+        await real_sleep(0.001)
+        return "new result"
+
+    monkeypatch.setattr(server, "synthesize_speech", no_audio)
+    monkeypatch.setattr(server.asyncio, "sleep", fast_sleep)
+    server._active_lookups.clear()
+    server._latest_lookup_by_type.clear()
+
+    async def run_test():
+        task1 = asyncio.create_task(server._lookup_and_report("screen", slow_lookup, ws))
+        await real_sleep(0.005)
+        task2 = asyncio.create_task(server._lookup_and_report("screen", fast_lookup, ws))
+        await asyncio.gather(task1, task2)
+
+    asyncio.run(run_test())
+
+    text_messages = [m["text"] for m in ws.messages if m.get("type") == "text"]
+    assert text_messages == ["new result"]
+
+
+def test_lookup_and_report_base64_encodes_audio(monkeypatch):
+    ws = _FakeWS()
+    real_sleep = asyncio.sleep
+
+    async def fake_audio(_text):
+        return b"abc123"
+
+    async def fast_sleep(_delay):
+        await real_sleep(0)
+
+    async def lookup():
+        return "spoken result"
+
+    monkeypatch.setattr(server, "synthesize_speech", fake_audio)
+    monkeypatch.setattr(server.asyncio, "sleep", fast_sleep)
+    server._active_lookups.clear()
+    server._latest_lookup_by_type.clear()
+
+    asyncio.run(server._lookup_and_report("screen", lookup, ws))
+
+    audio_messages = [m for m in ws.messages if m.get("type") == "audio"]
+    assert len(audio_messages) == 1
+    assert audio_messages[0]["data"] == "YWJjMTIz"
+    assert audio_messages[0]["text"] == "spoken result"
+
+
+def test_lookup_and_report_logs_full_result(monkeypatch, caplog):
+    ws = _FakeWS()
+    real_sleep = asyncio.sleep
+    long_result = "This is a much longer screen description that should appear in full in the debug log without being truncated midway through the sentence."
+
+    async def no_audio(_text):
+        return None
+
+    async def fast_sleep(_delay):
+        await real_sleep(0)
+
+    async def lookup():
+        return long_result
+
+    monkeypatch.setattr(server, "synthesize_speech", no_audio)
+    monkeypatch.setattr(server.asyncio, "sleep", fast_sleep)
+    server._active_lookups.clear()
+    server._latest_lookup_by_type.clear()
+
+    with caplog.at_level(logging.INFO):
+        asyncio.run(server._lookup_and_report("screen", lookup, ws))
+
+    assert f"Lookup screen complete: {long_result}" in caplog.text
diff --git a/tests/test_project_discovery.py b/tests/test_project_discovery.py
new file mode 100644
index 00000000..3d13444c
--- /dev/null
+++ b/tests/test_project_discovery.py
@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import server
+
+
+def _init_repo(path: Path, branch: str = "main"):
+    path.mkdir(parents=True, exist_ok=True)
+    git_dir = path / ".git"
+    git_dir.mkdir()
+    (git_dir / "HEAD").write_text(f"ref: refs/heads/{branch}")
+
+
+def test_scan_projects_sync_includes_repo_root_and_common_roots(tmp_path, monkeypatch):
+    repo_root = tmp_path / "VS_Code" / "jarvis"
+    _init_repo(repo_root, "main")
+
+    projects_root = tmp_path / "Projects"
+    alpha = projects_root / "alpha"
+    _init_repo(alpha, "feature-x")
+
+    monkeypatch.setattr(server, "REPO_ROOT", repo_root)
+    monkeypatch.setattr(server, "PROJECT_SCAN_ROOTS", [projects_root])
+
+    projects = server._scan_projects_sync()
+
+    assert projects == [
+        {"name": "jarvis", "path": str(repo_root.resolve()), "branch": "main"},
+        {"name": "alpha", "path": str(alpha.resolve()), "branch": "feature-x"},
+    ]
+
+
+def test_find_project_dir_falls_back_to_fresh_scan_when_cache_is_empty(tmp_path, monkeypatch):
+    repo_root = tmp_path / "VS_Code" / "jarvis"
+    _init_repo(repo_root, "main")
+
+    monkeypatch.setattr(server, "REPO_ROOT", repo_root)
+    monkeypatch.setattr(server, "PROJECT_SCAN_ROOTS", [])
+    monkeypatch.setattr(server, "cached_projects", [])
+
+    class _FakeRegistry:
+        def get_by_name(self, name: str):
+            return None
+
+    monkeypatch.setattr(server, "dispatch_registry", _FakeRegistry())
+
+    assert server._find_project_dir("jarvis") == str(repo_root.resolve())
+
+
+def test_find_project_dir_uses_dispatch_registry_for_non_git_projects(tmp_path, monkeypatch):
+    project_dir = tmp_path / "prototype"
+    project_dir.mkdir()
+
+    monkeypatch.setattr(server, "cached_projects", [])
+    monkeypatch.setattr(server, "PROJECT_SCAN_ROOTS", [])
+
+    class _FakeRegistry:
+        def get_by_name(self, name: str):
+            return {"project_path": str(project_dir)}
+
+    monkeypatch.setattr(server, "dispatch_registry", _FakeRegistry())
+
+    assert server._find_project_dir("prototype") == str(project_dir)
diff --git a/tests/test_screen.py b/tests/test_screen.py
new file mode 100644
index 00000000..6cd3800e
--- /dev/null
+++ b/tests/test_screen.py
@@ -0,0 +1,30 @@
+import asyncio
+from pathlib import Path
+
+import screen
+
+
+def test_prepare_image_for_vision_keeps_small_file(tmp_path):
+    image_path = tmp_path / "screen.png"
+    image_path.write_bytes(b"x" * (screen.VISION_TARGET_IMAGE_BYTES - 10))
+
+    result = asyncio.run(screen._prepare_image_for_vision(image_path))
+
+    assert result == image_path
+
+
+def test_prepare_image_for_vision_compresses_large_file(tmp_path, monkeypatch):
+    image_path = tmp_path / "screen.png"
+    image_path.write_bytes(b"x" * (screen.VISION_TARGET_IMAGE_BYTES + 10))
+
+    async def fake_transform(input_path: Path, output_path: Path, max_pixels: int | None, quality: int) -> bool:
+        output_path.write_bytes(b"y" * 1024)
+        return True
+
+    monkeypatch.setattr(screen, "_run_image_transform", fake_transform)
+
+    result = asyncio.run(screen._prepare_image_for_vision(image_path))
+
+    assert result == tmp_path / "screen.vision.jpg"
+    assert result.exists()
+    assert result.stat().st_size == 1024
diff --git a/tests/test_screen_detection.py b/tests/test_screen_detection.py
new file mode 100644
index 00000000..7788b8d7
--- /dev/null
+++ b/tests/test_screen_detection.py
@@ -0,0 +1,9 @@
+import server
+
+
+def test_detect_action_fast_handles_what_is_on_my_screen():
+    assert server.detect_action_fast("what is on my screen") == {"action": "describe_screen"}
+
+
+def test_detect_action_fast_handles_tell_me_what_is_on_my_screen():
+    assert server.detect_action_fast("tell me what is on my screen") == {"action": "describe_screen"}
diff --git a/tests/test_weather.py b/tests/test_weather.py
new file mode 100644
index 00000000..4d1ba433
--- /dev/null
+++ b/tests/test_weather.py
@@ -0,0 +1,47 @@
+import json
+
+import server
+
+
+def test_format_location_label_uses_city_and_region():
+    assert server._format_location_label("Edmonton", "AB", "Canada") == "Edmonton, AB"
+
+
+def test_get_weather_location_prefers_env_override(monkeypatch):
+    monkeypatch.setenv("WEATHER_LOCATION_LABEL", "Edmonton, AB")
+    monkeypatch.setenv("WEATHER_LATITUDE", "53.5461")
+    monkeypatch.setenv("WEATHER_LONGITUDE", "-113.4938")
+
+    location = server._get_weather_location()
+
+    assert location == {
+        "latitude": 53.5461,
+        "longitude": -113.4938,
+        "label": "Edmonton, AB",
+    }
+
+
+def test_fetch_weather_sync_reports_celsius(monkeypatch):
+    monkeypatch.setattr(
+        server,
+        "_get_weather_location",
+        lambda: {"latitude": 53.5461, "longitude": -113.4938, "label": "Edmonton, AB"},
+    )
+
+    class _FakeResponse:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def read(self):
+            return json.dumps({"current": {"temperature_2m": 12.7}}).encode()
+
+    import urllib.request
+
+    monkeypatch.setattr(urllib.request, "urlopen", lambda *args, **kwargs: _FakeResponse())
+
+    text = server._fetch_weather_sync()
+
+    assert text == "Current weather in Edmonton, AB: 12.7°C"