fix: four sign-in/trial bugs from fresh-install testing

1. New email skipped onboarding: sign-out cleared token/plan/email but not
   onboarded/onboarded_plan, so a new email inherited the prior account's
   onboarded=True. Sign-out now clears the per-account onboarding + trial state.

2. Auto-start trial silently missed: the sign-in enroll is a one-shot with no
   log/retry; on a brand-new account it races (account not queryable yet) and
   left the user on the generic trial. Added a self-healing net in the daemon's
   /v1/me poll (fires for a signed-in Power build not-yet-Power, trial unused;
   server-idempotent) + logging on the sign-in path so it's never silent again.

3. 'Start trial' looked dead on failure: the handler only notified on
   'already used', not on a network error. Now notifies on failure too.

4. 'Manage on heard.dev' opened heard.dev/account — not a route (blank page).
   Points at /dashboard, which exists.

Full suite (841) + full ruff green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019GTBZjBGurqsHUHsjaU1gA

Author: sodiumsun

heard/daemon.py

@@ -1215,6 +1215,62 @@ def _stop_audio_monitor(self) -> None:
                 pass
             self._audio_monitor = None
 
+    def _maybe_autostart_power_trial(self, me: dict) -> None:
+        """Self-healing Power-trial enrollment, run on every /v1/me poll.
+
+        The sign-in-time enroll (url_scheme._maybe_start_power_trial) is a
+        one-shot that can miss — a brand-new account isn't queryable the instant
+        it's created, or a transient network blip drops the call — and it leaves
+        the user stuck on the generic trial. This backstops it: if this is the
+        Power build, they're signed in, they aren't already Power, and they
+        haven't used their one trial, enroll them. Server-idempotent (no-ops if
+        already power / trial used), so calling it every poll is safe."""
+        try:
+            if not (self.cfg.get("voice_service_cmd") or "").strip():
+                return  # not the Power build
+            token = (self.cfg.get("heard_token") or "").strip()
+            if not token:
+                return
+            if (me.get("plan") or "").strip().lower() == "power":
+                return  # already Power (paid or trialing)
+            if me.get("power_trial_used"):
+                return  # used their one trial — don't retry forever
+            import json as _json
+            import ssl as _ssl
+            import urllib.request as _urlreq
+
+            try:
+                import certifi  # type: ignore
+
+                ctx = _ssl.create_default_context(cafile=certifi.where())
+            except ImportError:
+                ctx = _ssl.create_default_context()
+            base_url = (
+                self.cfg.get("heard_api_base") or "https://api.heard.dev"
+            ).rstrip("/")
+            req = _urlreq.Request(
+                f"{base_url}/v1/power/trial/start",
+                method="POST",
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "User-Agent": "Heard-daemon/1.0",
+                },
+            )
+            with _urlreq.urlopen(req, timeout=8.0, context=ctx) as resp:
+                data = _json.loads(resp.read().decode("utf-8") or "{}")
+            if data.get("plan") == "power":
+                config.set_value("heard_plan", "power")
+                exp = int(data.get("trial_expires_at") or 0)
+                if exp:
+                    config.set_value("heard_trial_expires_at", exp)
+                config.set_value("power_trial_used", True)
+                _log("power_trial_autostarted", via="daemon_poll")
+                self._reload_config()
+            else:
+                _log("power_trial_autostart_noop", reason=str(data.get("reason") or "not_power"))
+        except Exception as e:
+            _log("power_trial_autostart_error", err=str(e))
+
     def _sync_plan_from_me(self, me: dict) -> None:
         """Persist plan + trial-expiry from a /v1/me snapshot when they've
         drifted from local config, then reload so the change takes effect.
@@ -3816,6 +3872,7 @@ def _refresh_account_usage(self) -> None:
                 self._account_usage = data
                 self._account_usage_at = _time.time()
                 self._sync_plan_from_me(data)
+                self._maybe_autostart_power_trial(data)
                 self._maybe_announce_friend_joined(data)
         except (_urlerr.HTTPError, _urlerr.URLError, TimeoutError, OSError, ValueError):
             # Stay quiet; menu bar shows the previous value (or nothing).

heard/home_window.py

@@ -625,6 +625,13 @@ def _act_signout(self, body):
                     config.set_value(key, "")
                 config.set_value("heard_trial_expires_at", 0)
                 config.set_value("byok_enabled", False)
+                # Onboarding + trial state are PER-ACCOUNT. Clearing them on sign-
+                # out means the next email always re-onboards (new users were
+                # skipping the wizard because the previous account's onboarded=True
+                # persisted) and can start its own trial.
+                config.set_value("onboarded", False)
+                config.set_value("onboarded_plan", "")
+                config.set_value("power_trial_used", False)
                 _reload_daemon()
                 self._push_state()
             except Exception as e:
@@ -661,10 +668,11 @@ def _act_upgrade_power(self, body):
 
         def _act_manage_account(self, body):
             # Open the browser to manage plan / payment / email on heard.dev.
+            # /account is not a route (blank page) — the dashboard is /dashboard.
             try:
                 import webbrowser
 
-                webbrowser.open("https://heard.dev/account")
+                webbrowser.open("https://heard.dev/dashboard")
             except Exception as e:
                 _log_bridge_error("manage_account", e)
 
@@ -830,7 +838,20 @@ def _work():
                         )
                     AppHelper.callAfter(self._push_state)
                 except Exception as e:
+                    # Don't fail silently — a dead-looking button is worse than an
+                    # error. Tell the user so it's clear the click registered.
                     _log_bridge_error("start_power_trial", e)
+                    try:
+                        from heard import notify
+
+                        AppHelper.callAfter(
+                            notify.notify,
+                            "Heard",
+                            "Couldn't start your Power trial - check your connection and try again.",
+                            "power_trial",
+                        )
+                    except Exception:
+                        pass
 
             threading.Thread(target=_work, daemon=True).start()
 

heard/url_scheme.py

@@ -102,8 +102,14 @@ def _maybe_start_power_trial(token: str) -> None:
             exp = int(data.get("trial_expires_at") or 0)
             if exp:
                 config.set_value("heard_trial_expires_at", exp)
-    except Exception:
-        pass
+            print(f"[power_trial] sign-in autostart OK (exp={exp})")
+        else:
+            # Not power — usually a brand-new-account race (account not queryable
+            # yet). The daemon's /v1/me poll retries this within ~5 min, so it
+            # self-heals. Logged so it's never a silent mystery again.
+            print(f"[power_trial] sign-in autostart no-op: {data.get('reason') or data}")
+    except Exception as e:
+        print(f"[power_trial] sign-in autostart failed: {e}")
 
 
 def _refresh_byok_enabled(token: str) -> None:

tests/test_daemon_power_trial.py

@@ -0,0 +1,79 @@
+"""The daemon's self-healing Power-trial enrollment net.
+
+Backstops the sign-in-time enroll, which can miss on a brand-new account (not
+queryable the instant it's created) or a transient blip. Runs on every /v1/me
+poll, so it must be correctly gated: fire only for a signed-in Power build that
+isn't already Power and hasn't used its one trial.
+"""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import MagicMock, patch
+
+from heard.daemon import Daemon
+
+
+def _stub(cfg):
+    """A minimal object exposing just what the unbound method touches."""
+    s = Daemon.__new__(Daemon)
+    s.cfg = cfg
+    s._reload_config = lambda: None
+    return s
+
+
+POWER_CFG = {"voice_service_cmd": "{python} -m heard_power serve", "heard_token": "tok"}
+
+
+def _run(cfg, me):
+    """Call the net with urlopen mocked; return the mock so we can assert calls."""
+    resp = MagicMock()
+    resp.read.return_value = json.dumps(
+        {"plan": "power", "trial_expires_at": 111}
+    ).encode()
+    resp.__enter__.return_value = resp
+    with patch("urllib.request.urlopen", return_value=resp) as urlopen, patch(
+        "heard.daemon.config.set_value"
+    ) as setv:
+        Daemon._maybe_autostart_power_trial(_stub(dict(cfg)), me)
+    return urlopen, setv
+
+
+def test_fires_for_signed_in_power_build_not_yet_power():
+    urlopen, setv = _run(POWER_CFG, {"plan": "free", "power_trial_used": False})
+    urlopen.assert_called_once()
+    # persisted the trial locally
+    keys = {c.args[0] for c in setv.call_args_list}
+    assert "heard_plan" in keys and "power_trial_used" in keys
+
+
+def test_skips_on_oss_build_no_voice_service():
+    urlopen, _ = _run({"voice_service_cmd": "", "heard_token": "tok"}, {"plan": "free"})
+    urlopen.assert_not_called()
+
+
+def test_skips_when_not_signed_in():
+    urlopen, _ = _run(
+        {"voice_service_cmd": "cmd", "heard_token": ""}, {"plan": "free"}
+    )
+    urlopen.assert_not_called()
+
+
+def test_skips_when_already_power():
+    urlopen, _ = _run(POWER_CFG, {"plan": "power"})
+    urlopen.assert_not_called()
+
+
+def test_skips_when_trial_already_used():
+    urlopen, _ = _run(POWER_CFG, {"plan": "free", "power_trial_used": True})
+    urlopen.assert_not_called()
+
+
+def test_network_error_is_swallowed():
+    with patch("urllib.request.urlopen", side_effect=OSError("down")), patch(
+        "heard.daemon.config.set_value"
+    ):
+        # must not raise
+        Daemon._maybe_autostart_power_trial(
+            _stub(dict(POWER_CFG)), {"plan": "free", "power_trial_used": False}
+        )