pulseml 0.2.0__tar.gz → 0.2.2__tar.gz

{pulseml-0.2.0 → pulseml-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulseml
-Version: 0.2.0
+Version: 0.2.2
 Summary: A live ML training debugger - GUI or CLI, any backend (NumPy, PyTorch, TensorFlow, CuPy, JAX).
 Author-email: Yash Patel <codeyash09@gmail.com>
 License: Proprietary

{pulseml-0.2.0 → pulseml-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pulseml"
-version = "0.2.0"
+version = "0.2.2"
 description = "A live ML training debugger - GUI or CLI, any backend (NumPy, PyTorch, TensorFlow, CuPy, JAX)."
 readme = "README.md"
 requires-python = ">=3.9"

{pulseml-0.2.0 → pulseml-0.2.2}/src/pulse/pulse.py

@@ -3373,27 +3373,58 @@ def auto_track(train_fn=None, throttle_interval=1.0, code_text=None, project_roo
                         # macOS/Linux: Resets raw terminal modes and clears the screen
                         subprocess.run('stty sane', shell=True)
                         subprocess.run('clear', shell=True)
-                    # Replace this part in your RESTART block:
-                    try:
-                        restart_result = subprocess.run(
-                            [sys.executable, script_path] + sys.argv[1:],
-                            capture_output=True,
-                            text=True
+                    # Retry the restart itself instead of falling back to
+                    # "keep running the old, already-in-memory process" on
+                    # a bad exit code. A nonzero exit almost always means
+                    # the replacement process crashed immediately (the
+                    # agent's fix didn't fully take, or introduced a new
+                    # bug) -- silently resuming the OLD code just means
+                    # the same already-broken run limps along unsupervised
+                    # with nobody watching. Retrying gives a transient
+                    # cause (a file/port briefly held by the exiting old
+                    # process, a flaky import) a real chance to clear.
+                    # Capped, not infinite, so a deterministically-broken
+                    # script can't spin forever burning compute unattended.
+                    MAX_RESTART_ATTEMPTS = 5
+                    RETRY_BACKOFF_SECONDS = 3
+
+                    restart_argv = [sys.executable, script_path] + sys.argv[1:]
+                    attempt = 0
+                    restarted_ok = False
+                    while attempt < MAX_RESTART_ATTEMPTS:
+                        attempt += 1
+                        try:
+                            restart_result = subprocess.run(
+                                restart_argv,
+                                capture_output=True,
+                                text=True,
+                            )
+                        except Exception as exc:
+                            print(f"[PULSE] Restart attempt {attempt}/{MAX_RESTART_ATTEMPTS} failed to launch ({exc}).")
+                            if attempt < MAX_RESTART_ATTEMPTS:
+                                time.sleep(min(RETRY_BACKOFF_SECONDS * attempt, 30))
+                            continue
+
+                        if restart_result.returncode == 0:
+                            restarted_ok = True
+                            break
+
+                        print(
+                            f"\n[PULSE] Replacement training process exited with code "
+                            f"{restart_result.returncode} (attempt {attempt}/{MAX_RESTART_ATTEMPTS})."
                         )
-                    except Exception as exc:
-                        print(f"[PULSE] Restart failed ({exc}); continuing the current training process.")
-                        continue
-
-                    if restart_result.returncode == 0:
+                        if restart_result.stderr:
+                            print("[PULSE] STDERR from failed run:\n", restart_result.stderr)
+                        if restart_result.stdout:
+                            print("[PULSE] STDOUT from failed run:\n", restart_result.stdout)
+                        if attempt < MAX_RESTART_ATTEMPTS:
+                            print("[PULSE] Retrying restart...")
+                            time.sleep(min(RETRY_BACKOFF_SECONDS * attempt, 30))
+
+                    if restarted_ok:
                         sys.exit(0)
-                    
-                    # Print the captured errors so you can see why it exited with code 1!
-                    print(f"\n[PULSE] Replacement training process exited with code {restart_result.returncode}.")
-                    if restart_result.stderr:
-                        print("[PULSE] STDERR from failed run:\n", restart_result.stderr)
-                    if restart_result.stdout:
-                        print("[PULSE] STDOUT from failed run:\n", restart_result.stdout)
-                    print("[PULSE] Continuing the current process.")
+
+                    print(f"[PULSE] ⚠ Giving up after {MAX_RESTART_ATTEMPTS} restart attempts -- continuing the current process.")
         # bad (NaN/inf, a loss spike) and asked training to hold here until
         # the user hits "Resume Training" -- or a fix gets applied and they
         # resume manually. Blocks this exact line from executing further,
@@ -3510,6 +3541,24 @@ def _install_cli_excepthook(cli):
     previous_hook = sys.excepthook
 
     def _hook(exc_type, exc_value, exc_tb):
+        # Disarm the global line/call tracer immediately. Once the script
+        # has crashed, nothing below should still be traced -- and if we
+        # leave `sys.settrace` pointed at `cli_tracer`, it stays the
+        # process-wide trace function into interpreter shutdown, where it
+        # gets invoked on unrelated __del__ calls (e.g. litellm's
+        # AsyncHTTPHandler) after module globals have already been cleared
+        # to None. That produces a second, uncatchable "Exception ignored
+        # in ..." failure from *inside* the tracer, separate from (and
+        # after) whatever we report here.
+        sys.settrace(None)
+        try:
+            frame = exc_tb.tb_frame if exc_tb else None
+            while frame is not None:
+                frame.f_trace = None
+                frame = frame.f_back
+        except Exception:
+            pass
+
         previous_hook(exc_type, exc_value, exc_tb)
         if issubclass(exc_type, KeyboardInterrupt):
             return
@@ -3603,14 +3652,29 @@ def _start_cli_tracker(
     cli.extra_files = dict(extra_files or {})
     cli.pending_startup_error = startup_error
     cli.print_banner()
-    _install_cli_excepthook(cli)
+    # Agent/provider setup used to be deferred until cli_tracer saw its
+    # first 'line' event with a trackable/resolved local in scope -- fine
+    # for a training loop, but it meant any crash before that point (e.g.
+    # failing during data loading, before the loop even starts) left
+    # cli.agent_provider unset, so the crash hook below had no agent to
+    # hand the traceback to and could only print "no AI agent is
+    # configured". discover_variables() already falls back to the
+    # statically-discovered `cli.discovered` names (populated from AST
+    # parsing at auto_track()-call time, before any user code runs) when
+    # there are no live locals yet, so setup doesn't actually need to wait
+    # for a live frame -- run it eagerly, before the excepthook can matter.
+    cli.interactive_setup()
 
     if startup_error:
         print("[Pulse] The function passed to auto_track() raised an exception during its dry run:")
         print(startup_error)
-        print("[Pulse] Set up an AI agent below and Pulse will offer to diagnose/fix it before continuing.\n")
+        if cli.agent_provider:
+            print("[Pulse] Pulse will offer to diagnose/fix it (via the agent set up above) before continuing.\n")
+        else:
+            print("[Pulse] No agent configured (see summary above) -- run /agent to set one up before continuing.\n")
+
+    _install_cli_excepthook(cli)
 
-    setup_done = {"value": False}
     last_logged = {"t": 0.0}
 
     # ------------------------------------------------------------------
@@ -3641,7 +3705,7 @@ def _start_cli_tracker(
     # next window. Between windows, the training loop runs at native,
     # untraced speed.
     _CAPTURE_SPAN = min(0.05, throttle_interval / 4 if throttle_interval > 0 else 0.05)
-    window = {"open": True, "closes_at": 0.0}  # start open so setup can run immediately
+    window = {"open": True, "closes_at": 0.0}  # start open so the first snapshot can run immediately
 
     def _close_window():
         window["open"] = False
@@ -3663,6 +3727,11 @@ def _start_cli_tracker(
             if window["open"]:
                 _close_window()
 
+    # Setup now runs eagerly, before tracing even starts (see above), so
+    # the ticker can start right away too -- no need to wait for the
+    # tracer to see a live frame first.
+    threading.Thread(target=_ticker, daemon=True).start()
+
     def cli_tracer(frame, event, arg):
         filename = frame.f_code.co_filename
         if _is_library_frame(filename):
@@ -3709,21 +3778,6 @@ def _start_cli_tracker(
                 ):
                     cli.var_states[name] = "track"
 
-        if not setup_done["value"]:
-            has_resolved_shape = any(shape is not None for shape in cli.discovered.values())
-            has_trackable_local = any(
-                not n.startswith("__") and is_trackable(v) for n, v in local_vars.items()
-            )
-            if has_resolved_shape or has_trackable_local:
-                cli.watch_locals = local_vars
-                cli.interactive_setup()
-                setup_done["value"] = True
-                # Setup is interactive/blocking; once it's done, start the
-                # background ticker that opens/closes future windows. (Kept
-                # off until now so setup itself isn't racing a window close.)
-                threading.Thread(target=_ticker, daemon=True).start()
-            return cli_tracer
-
         cli.watch_locals = local_vars
 
         now = time.time()

{pulseml-0.2.0 → pulseml-0.2.2}/src/pulse/pulse_cli.py

@@ -184,6 +184,68 @@ _YELLOW = "\033[93m"
 _PULSE_RE = re.compile(r"Pulse(?:\s(?:CLI|AI))?")
 
 
+# ----------------------------------------------------------------------------
+# Terms of Service -- the actual license Pulse ships under (mirrors the
+# LICENSE file in the Pulse GitHub repo). Shown in full at sign-up (see
+# _prompt_tos_acceptance) and its acceptance is what cloud.record_tos_
+# acceptance timestamps server-side. PULSE_TOS_URL, if set, is shown
+# alongside this as a link to the canonical hosted copy -- update that env
+# var (and this text, if the license is ever revised) together so the two
+# never drift apart.
+# ----------------------------------------------------------------------------
+PULSE_LICENSE_TEXT = """\
+PULSE PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 Yash Patel. All Rights Reserved.
+
+This software and associated files (the "Software") are the proprietary
+property of the copyright holder. The Software is licensed, not sold.
+
+1. GRANT OF LICENSE
+   Subject to the terms of this license, the copyright holder grants you a
+   limited, non-exclusive, non-transferable, revocable license to install
+   and run the Software for your own internal use.
+
+2. RESTRICTIONS
+   Except as expressly permitted above, you may NOT, and may not permit
+   others to:
+   (a) copy, reproduce, distribute, sublicense, rent, lease, or resell the
+       Software;
+   (b) modify, adapt, translate, or create derivative works based on the
+       Software;
+   (c) reverse engineer, decompile, disassemble, or otherwise attempt to
+       derive the source code of the Software, except to the extent this
+       restriction is prohibited by applicable law;
+   (d) remove, obscure, or alter any proprietary notices on the Software;
+   (e) use the Software to build a competing product or service.
+
+3. FUTURE PAID TERMS
+   The copyright holder reserves the right to change pricing, introduce
+   paid tiers or license keys, limit functionality, or discontinue free
+   distribution of future versions at any time. Continued use of any
+   future version may be subject to additional terms, including payment.
+
+4. NO WARRANTY
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+   NONINFRINGEMENT.
+
+5. LIMITATION OF LIABILITY
+   IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM,
+   DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION
+   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+6. TERMINATION
+   This license is effective until terminated. It will terminate
+   automatically without notice if you fail to comply with any of its
+   terms. Upon termination, you must cease all use of the Software and
+   destroy all copies in your possession.
+
+For licensing inquiries, contact: codeyash09@gmail.com
+"""
+
+
 def _highlight_pulse(text: str, base_color: Optional[str] = None) -> str:
     """Color every occurrence of 'Pulse' (and 'Pulse CLI'/'Pulse AI') orange,
     resuming `base_color` afterward so nesting inside a red/blue line works."""
@@ -297,7 +359,16 @@ SYSTEM_PROMPT = (
     "of training, adjust the dial so future auto-intervention checks match reality instead of "
     "either missing real trouble or crying wolf on normal noise. Only send this when you have an "
     "actual reason from the data, not by default.\n"
-    "  Put CALC:/PROMOTE:/GPUTRACK:/GPUUNTRACK:/SENSITIVITY: lines anywhere in your Reasoning, not in the "
+    "  NORMAL_START: <comma-separated var=value pairs, or 'none'>\n"
+    "    Spike detection normally needs several real data points before it has a baseline to "
+    "compare against, which means a genuine explosion in the first few steps of training can go "
+    "undetected. If you can estimate a loss-like tracked variable's expected value at the very "
+    "start of training from the code alone (e.g. a randomly-initialized N-class classifier's "
+    "cross-entropy loss starts near ln(N); a policy's initial reward is often near a known "
+    "random-policy baseline), send it here so Pulse can catch a real explosion from step one "
+    "instead of waiting for history to accumulate. Only estimate what you can actually justify "
+    "from the code -- omit a variable (or send 'none') rather than guess.\n"
+    "  Put CALC:/PROMOTE:/GPUTRACK:/GPUUNTRACK:/SENSITIVITY:/NORMAL_START: lines anywhere in your Reasoning, not in the "
     "Diagnosis or Fix.\n\n"
     "PERIODIC GPU CHECK-IN:\n"
     "Every 15 minutes after Pulse starts, if you have an AI provider configured, Pulse will send "
@@ -653,8 +724,20 @@ class PulseCLI:
         # one signal instead of moving the whole dial.
         self.explosion_multiplier: Optional[float] = None       # loss spike: latest > baseline * N
         self.plateau_range_frac: Optional[float] = None         # plateau: window range < frac * |latest|
-        self.oscillation_flip_threshold: Optional[int] = None   # oscillation: sign flips required (of 19)
-        self.oscillation_delta_frac: Optional[float] = None     # oscillation: avg |delta| > frac * |latest|
+        self.oscillation_flip_threshold: Optional[int] = None   # oscillation: sign flips required (of 18)
+        self.oscillation_delta_frac: Optional[float] = None     # oscillation: avg |delta| > frac * scale
+        self.stagnation_frac: Optional[float] = None            # stagnation: long-window improvement < frac * |early mean|
+        # Agent-estimated (from reading the code, via a NORMAL_START:
+        # directive -- see _apply_directives) expected starting value for
+        # a loss-like tracked variable. Explosion detection normally needs
+        # several real finite data points before it has anything to
+        # compare `latest` against, which means a genuine blow-up in the
+        # first few steps of training can slip through undetected -- this
+        # gives it a code-derived anchor to compare against from step one,
+        # before real history exists. See _prime_at_start, which asks the
+        # agent for this automatically, once, before the first step.
+        self._normal_start_baselines: Dict[str, float] = {}
+        self._start_primed: bool = False   # _prime_at_start runs at most once per process
         self._last_intervention_signature: Optional[str] = None
         # /code is on by default -- every manually-asked question includes
         # the training code (and any cross-file context) unless turned off.
@@ -1480,6 +1563,39 @@ class PulseCLI:
                 # deliberately NOT marked dirty here -- it hasn't changed
                 # (see above), so there's nothing to re-send.
                 self._cloud_dirty_fields.update({"uptime_seconds", "downtime_seconds"})
+                # Preload this session's already-synced history so THIS
+                # process's flushes extend it instead of quietly replacing
+                # it. self._agent_logs/_error_tracebacks/_telemetry/
+                # _incidents all start empty in __init__ -- with nothing
+                # more done, the first flush from here would PATCH the
+                # whole array column (see _build_cloud_patch_body) down to
+                # just whatever this process adds, erasing every entry
+                # logged before the restart even though it's still sitting
+                # in local memory of a process that's gone. Best-effort:
+                # if this fetch fails (offline blip, etc.) we still carry
+                # on -- worst case is the pre-restart history is briefly
+                # at risk on the next flush rather than the run refusing
+                # to continue.
+                try:
+                    existing = cloud.fetch_debug_session(self.debug_session_id)
+                except cloud.SupabaseError:
+                    existing = None
+                if existing:
+                    self._agent_logs = cloud.decode_entries(existing.get("agent_logs"))
+                    self._error_tracebacks = cloud.decode_entries(existing.get("error_tracebacks"))
+                    self._telemetry = cloud.decode_entries(existing.get("telemetry"))
+                    self._incidents = cloud.decode_entries(existing.get("incidents"))
+                    cprint(
+                        f"[Pulse] Loaded {len(self._agent_logs)} agent log(s), {len(self._incidents)} "
+                        f"incident(s) from before the restart -- history preserved."
+                    )
+                else:
+                    cprint(
+                        "[Pulse] ⚠ Could not load this session's history before the restart -- "
+                        "new entries will be appended locally, but the next sync may not include "
+                        "everything logged before the restart.",
+                        color=_YELLOW,
+                    )
                 cprint(f"[Pulse] Resumed git commit {sha[:10]}… -- carried over, not re-detected (see /commit to update it manually).")
                 cprint(f"[Pulse] Resumed debug session (id={self.debug_session_id[:8]}…) after restart -- uptime/downtime counters carried over.")
             else:
@@ -1608,6 +1724,17 @@ class PulseCLI:
                     self.email = env_user
                     token = cloud.attach_session_token(self.user_id)
                     cloud.save_cached_credentials(self.user_id, self.email, self.team_id, session_token=token)
+                except cloud.SupabaseEmailConfirmationRequired:
+                    # Account created, but this deployment requires email
+                    # confirmation before a session can be issued -- an
+                    # unattended job can't click that link, so there's
+                    # nothing more to do here this run. Not a "login
+                    # failed" -- just fall through to local (no-cloud) mode
+                    # for this run and let a human confirm and re-run.
+                    cprint(
+                        f"[Pulse] Confirm your account: check {env_user}'s email for a confirmation link, "
+                        "then log in. Continuing this run in local (no-cloud) mode.",
+                    )
                 except cloud.SupabaseError as exc:
                     cprint(f"[Pulse] ⚠ Non-interactive login failed ({exc}). Continuing in local (no-cloud) mode.", color=_RED)
             else:
@@ -1624,31 +1751,39 @@ class PulseCLI:
             _flush_stdin()
             cprint("\n--- Pulse Cloud Authentication ---")
             resp = input(
-                "[Pulse] Select an option: (s)ign up / (l)og in / (r)ecover account > "
-            ).strip().lower()
+                "[Pulse] (s)ign up [default] / (l)og in / (r)ecover account > "
+            ).strip().lower() or "s"
 
             if resp in ("s", "signup", "sign up"):
                 _flush_stdin()
-                email = input("email (>=8 chars: letters, numbers, _, -) > ").strip()
-                if not email:
-                    cprint("[Pulse] email cannot be blank.", color=_RED)
-                    continue
-                if not cloud.is_valid_email(email):
-                    cprint("[Pulse] emails must be >=8 characters: letters, numbers, underscores, and hyphens only.", color=_RED)
-                    continue
-                password = getpass.getpass("Password (min. 8 characters) > ")
-                if len(password) < 8:
-                    cprint("[Pulse] Password must be at least 8 characters.", color=_RED)
-                    continue
-                confirm_password = getpass.getpass("Confirm password > ")
-                if password != confirm_password:
-                    # A typo here with no confirmation step means signing up
-                    # with a password the user doesn't actually know -- and
-                    # with no email on file yet at this point, there'd be no
-                    # way back in. Re-prompt from the top of sign-up rather
-                    # than silently keeping whichever one was typed first.
-                    cprint("[Pulse] Passwords didn't match. Let's try again.", color=_RED)
-                    continue
+                # Retry only the field that actually failed (email or
+                # password) instead of bouncing back to the top-level
+                # "sign up / log in / recover" menu on every typo -- that
+                # used to mean a single password mismatch cost you a full
+                # re-type of the email address too.
+                while True:
+                    email = input("email (e.g. name@example.com, min. 8 characters) > ").strip()
+                    if not email:
+                        cprint("[Pulse] email cannot be blank.", color=_RED)
+                        continue
+                    if not cloud.is_valid_email(email):
+                        cprint("[Pulse] enter a valid email address (min. 8 characters), e.g. name@example.com.", color=_RED)
+                        continue
+                    break
+                while True:
+                    password = getpass.getpass("Password (min. 8 characters) > ")
+                    if len(password) < 8:
+                        cprint("[Pulse] Password must be at least 8 characters.", color=_RED)
+                        continue
+                    confirm_password = getpass.getpass("Confirm password > ")
+                    if password != confirm_password:
+                        # A typo here with no confirmation step means signing up
+                        # with a password the user doesn't actually know -- and
+                        # with no email on file yet at this point, there'd be no
+                        # way back in. Re-prompt for password only, not email.
+                        cprint("[Pulse] Passwords didn't match. Let's try again.", color=_RED)
+                        continue
+                    break
                 accepted = self._prompt_tos_acceptance()
                 if not accepted:
                     cprint("[Pulse] Sign up cancelled -- acceptance is required to create an account.")
@@ -1664,6 +1799,38 @@ class PulseCLI:
                     cloud.save_cached_credentials(self.user_id, self.email, self.team_id, session_token=token)
                     self._show_recovery_code(cloud.attach_recovery_code(self.user_id))
                     return
+                except cloud.SupabaseEmailConfirmationRequired:
+                    # The account WAS created -- this isn't a failure. The
+                    # OLD behavior here just printed a message and fell
+                    # back to the top-level menu, which meant: leave the
+                    # CLI, go confirm in email, come back, remember to
+                    # pick "log in" instead of "sign up", and retype the
+                    # email+password you just typed 10 seconds ago. That's
+                    # exactly the kind of drop-off point that loses a
+                    # just-converted cold-email lead. Instead, stay in
+                    # this flow and retry with the SAME credentials
+                    # already in memory -- the only thing left to do is
+                    # click the link and hit Enter.
+                    cprint("[Pulse] Almost there -- check your email for a confirmation link and click it.")
+                    while True:
+                        _flush_stdin()
+                        resp2 = input(
+                            "Press Enter once confirmed to continue (or type 'skip' to do this later) > "
+                        ).strip().lower()
+                        if resp2 == "skip":
+                            cprint("[Pulse] No problem -- run Pulse again and choose (l)og in once you've confirmed.")
+                            break
+                        try:
+                            user = cloud.log_in(email, password)
+                        except cloud.SupabaseError as exc2:
+                            cprint(f"[Pulse] Not confirmed yet ({exc2}). Check your email and try again.", color=_YELLOW)
+                            continue
+                        cprint(f"[Pulse] ✓ Confirmed! Signed in as {email}.")
+                        self.user_id = user["id"]
+                        self.email = email
+                        token = cloud.attach_session_token(self.user_id)
+                        cloud.save_cached_credentials(self.user_id, self.email, self.team_id, session_token=token)
+                        return
                 except cloud.SupabaseError as exc:
                     cprint(f"[Pulse] ⚠ Sign up failed: {exc}", color=_RED)
 
@@ -1735,19 +1902,43 @@ class PulseCLI:
         self.email = None
 
     def _prompt_tos_acceptance(self) -> bool:
-        """Legal note for whoever's deploying this: the URLs below are
-        placeholders -- point PULSE_TOS_URL/PULSE_PRIVACY_URL at your
-        actual Terms of Service and Privacy Policy (drafted by an actual
-        lawyer, not by Pulse) before relying on this for anything. This
-        function only builds the ACCEPTANCE MECHANISM (the prompt, and
-        recording a timestamp -- see cloud.record_tos_acceptance) that a
-        real ToS/Privacy Policy needs; it doesn't write the legal text
-        itself."""
-        tos_url = os.environ.get("PULSE_TOS_URL", "(set PULSE_TOS_URL to link your Terms of Service here)")
+        """Show a short summary of the Pulse license up front (full text
+        is PULSE_LICENSE_TEXT, mirrored from the LICENSE file in the
+        Pulse GitHub repo, and is always one keystroke away via 'full')
+        and require typing 'yes' to accept before an account is created.
+
+        The full ~50-line license used to be printed unconditionally
+        before every sign-up -- legally fine, but it's exactly the kind
+        of wall of text that makes someone who just clicked through from
+        a cold email bail before ever seeing the product. A short,
+        scannable summary gets the same acceptance (still gated on
+        actually typing 'yes', still timestamped server-side by
+        cloud.record_tos_acceptance right after this returns True) without
+        that drop-off risk, while anyone who wants the full text still
+        gets it by typing 'full'.
+
+        PULSE_PRIVACY_URL, if set, is shown alongside it for a separate
+        privacy policy (this license covers software use, not data
+        handling) -- point that env var at your actual Privacy Policy
+        before relying on this for anything.
+        """
         privacy_url = os.environ.get("PULSE_PRIVACY_URL", "(set PULSE_PRIVACY_URL to link your Privacy Policy here)")
-        print(f"\nTerms of Service: {tos_url}\nPrivacy Policy:   {privacy_url}")
+        tos_url = os.environ.get("PULSE_TOS_URL")
+        print(
+            "\nQuick terms before you create an account:\n"
+            "  • Pulse is proprietary software, licensed (not sold) for your own use.\n"
+            "  • No redistributing, reselling, or reverse-engineering it, and no using it to build a competing product.\n"
+            "  • Provided as-is, no warranty -- pricing/paid tiers may be introduced for future versions.\n"
+        )
+        if tos_url:
+            print(f"Full license: {tos_url}")
+        print(f"Privacy Policy: {privacy_url}\n")
         _flush_stdin()
-        resp = input("Type 'yes' to accept and create your account > ").strip().lower()
+        resp = input("Type 'yes' to accept (or 'full' to read the complete license first) > ").strip().lower()
+        if resp == "full":
+            print(f"\n{PULSE_LICENSE_TEXT}")
+            _flush_stdin()
+            resp = input("Type 'yes' to accept and create your account > ").strip().lower()
         return resp == "yes"
 
     def _show_recovery_code(self, code: Optional[str]) -> None:
@@ -1878,6 +2069,28 @@ class PulseCLI:
                 cprint("[Pulse] Non-interactive mode and no unambiguous workspace to pick -- continuing without a team.")
             return
 
+        # A brand-new sign-up (or anyone who currently belongs to zero
+        # workspaces) has nothing to actually pick between here -- the
+        # old behavior forced everyone through this menu regardless, with
+        # no Enter-key default, meaning a just-signed-up trial user's very
+        # next required action was "type c, then optionally type a GitHub
+        # repo URL" before they could do anything else. Skip straight to
+        # a silently auto-created personal workspace instead; joining a
+        # teammate's workspace with a code is one command away (/repo can
+        # set a repo on it later, too), but creating your own shouldn't
+        # need a prompt at all when there's nothing else it could be.
+        if not existing:
+            try:
+                team = cloud.create_team(self.user_id, repo=cloud.git_remote_url(self._repo_cwd), cwd=self._repo_cwd)
+                self.team_id = team["team_id"]
+                self.team_join_code = team.get("join_code")
+                self.team_admin_ids = list(team.get("admin_ids") or [])
+                cprint(f"[Pulse] ✓ Workspace ready (join code: {self.team_join_code}) -- share this to invite teammates, or /repo to set a repo.")
+                cloud.save_cached_credentials(self.user_id, self.email, self.team_id)
+            except cloud.SupabaseError as exc:
+                cprint(f"[Pulse] ⚠ Could not create a workspace ({exc}) -- continuing without a team. Try /repo or restart to pick one.", color=_RED)
+            return
+
         while True:
             _flush_stdin()
             cprint("\n--- Pulse Workspace ---")
@@ -2092,6 +2305,66 @@ class PulseCLI:
         self.team_id = None
         self.debug_session_id = None
 
+    def _cmd_logout(self, arg: str) -> None:
+        """/logout -- sign out of the account currently in use for this
+        run, then immediately offers to sign back in (as the same account
+        or a different one) without having to restart Pulse. Revokes the
+        server-side session token (so the cached credentials.json on this
+        machine can't silently log back in on its own) and clears the
+        local cache. If a new account signs in, this also re-runs the
+        workspace picker and opens a fresh cloud debug session under that
+        identity -- the old session is flushed and left as-is on the
+        dashboard rather than mixing two identities' data into one row.
+        """
+        if not self.user_id:
+            cprint("[Pulse] Not signed in to Pulse Cloud -- nothing to log out of.")
+            return
+        if self.non_interactive:
+            cprint("[Pulse] /logout requires an interactive session.")
+            return
+
+        old_email = self.email
+
+        # Flush anything still pending for the CURRENT session/identity
+        # before switching -- otherwise a dirty field written after
+        # logout could still get attributed to the old debug session.
+        self._flush_cloud_now()
+
+        cloud.revoke_session_token(self.user_id)  # best-effort; never raises
+        cloud.clear_cached_credentials()
+        self.user_id = None
+        self.email = None
+        self.team_id = None
+        self.team_admin_ids = []
+        self.debug_session_id = None
+        cprint(f"[Pulse] ✓ Logged out of {old_email}.")
+
+        try:
+            self._auth_flow()
+        except cloud.SupabaseError as exc:
+            cprint(f"[Pulse] ⚠ Could not sign in to Pulse cloud, continuing locally: {exc}", color=_RED)
+            return
+
+        if not self.user_id:
+            cprint("[Pulse] Continuing this run in local (no-cloud) mode.")
+            return
+
+        try:
+            self._team_flow()
+        except cloud.SupabaseError as exc:
+            cprint(f"[Pulse] ⚠ Team setup failed, continuing without a team: {exc}", color=_RED)
+
+        try:
+            sha = self._last_synced_commit_sha or cloud.current_git_commit_sha(self._repo_cwd) or "unknown"
+            self.debug_session_id = cloud.create_debug_session(self.team_id, self.user_id, git_commit_sha=sha)
+            self._last_synced_commit_sha = sha
+            if self.debug_session_id:
+                cprint(f"[Pulse] Debug session started (id={self.debug_session_id}, commit={sha[:10] if sha != 'unknown' else 'unknown'}).")
+                atexit.register(self._flush_cloud_now)
+                self._last_cloud_flush = time.monotonic()
+        except cloud.SupabaseError as exc:
+            cprint(f"[Pulse] ⚠ Could not start a cloud debug session, continuing locally: {exc}", color=_RED)
+
     def _cmd_webhook(self, arg: str) -> None:
         """/webhook set <url> | /webhook test | /webhook off | /webhook
         -- a Slack-incoming-webhook-compatible URL that gets a message
@@ -2444,6 +2717,7 @@ class PulseCLI:
                 ("/code", "toggle whether questions include your training code"),
                 ("/password", "change your Pulse account password"),
                     ("/recover", "reset a forgotten password with a recovery code"),
+                ("/logout", "sign out, then sign back in as the same or a different account"),
             ]),
             ("Cloud & team", [
                 ("/cloud", "show sign-in, workspace, and sync status at a glance"),
@@ -3069,19 +3343,59 @@ class PulseCLI:
         # to route around.
         argv = [python_exe, script_path] + sys.argv[1:]
 
-        try:
-            # Synchronous run keeps stdin attached and handles spaces in paths correctly on Windows
-            result = subprocess.run(argv)
-        except Exception as exc:
-            cprint(f"[Pulse] ⚠ Restart failed ({exc}). Continuing current run.", color=_RED)
-            self._log_incident("restart_failed", str(exc))
-            return
+        # Retry the restart itself instead of ever falling back to "keep
+        # running the old, already-in-memory process" on a bad exit code.
+        # A nonzero exit here almost always means the replacement process
+        # crashed immediately (e.g. the agent's fix didn't fully fix it,
+        # or introduced a new bug) -- silently resuming the OLD code path
+        # used to look like a safe fallback, but for an unsupervised run
+        # it just means the SAME already-crashed-once code keeps limping
+        # along, or the loop quietly stalls, with nobody watching to
+        # notice. Retrying the launch instead gives a transient problem
+        # (e.g. a port/file briefly locked by the process that's still
+        # exiting, a flaky import) a real chance to clear, and gives the
+        # agent's fix -- which is already saved to disk -- more chances to
+        # actually take effect. Attempts are capped (not infinite) so a
+        # deterministically-broken script can't spin forever burning
+        # compute/cost unattended; MAX_RESTART_ATTEMPTS is the one knob to
+        # raise if that cap is ever too low for a given job.
+        MAX_RESTART_ATTEMPTS = 5
+        RETRY_BACKOFF_SECONDS = 3  # multiplied by attempt number, capped below
+
+        attempt = 0
+        while True:
+            attempt += 1
+            try:
+                # Synchronous run keeps stdin attached and handles spaces in paths correctly on Windows
+                result = subprocess.run(argv)
+            except Exception as exc:
+                cprint(f"[Pulse] ⚠ Restart attempt {attempt}/{MAX_RESTART_ATTEMPTS} failed to launch ({exc}).", color=_RED)
+                if attempt >= MAX_RESTART_ATTEMPTS:
+                    cprint(
+                        f"[Pulse] ⚠ Giving up after {MAX_RESTART_ATTEMPTS} restart attempts -- "
+                        "continuing current run with the old in-memory code.",
+                        color=_RED,
+                    )
+                    self._log_incident("restart_failed", f"Could not launch replacement process after {attempt} attempts: {exc}")
+                    return
+                time.sleep(min(RETRY_BACKOFF_SECONDS * attempt, 30))
+                continue
 
-        if result.returncode == 0:
-            sys.exit(0)
-        message = f"Replacement training process exited with code {result.returncode}"
-        cprint(f"[Pulse] ⚠ {message}. Continuing current run.", color=_RED)
-        self._log_incident("restart_failed", message)
+            if result.returncode == 0:
+                sys.exit(0)
+
+            message = f"Replacement training process exited with code {result.returncode} (attempt {attempt}/{MAX_RESTART_ATTEMPTS})"
+            if attempt >= MAX_RESTART_ATTEMPTS:
+                cprint(
+                    f"[Pulse] ⚠ {message}. Giving up after {MAX_RESTART_ATTEMPTS} attempts -- "
+                    "continuing current run with the old in-memory code.",
+                    color=_RED,
+                )
+                self._log_incident("restart_failed", message)
+                return
+
+            cprint(f"[Pulse] ⚠ {message}. Retrying restart...", color=_YELLOW)
+            time.sleep(min(RETRY_BACKOFF_SECONDS * attempt, 30))
 
     def _print_variable_summary(self) -> None:
         variables = self.discover_variables()
@@ -3448,18 +3762,21 @@ class PulseCLI:
     _GPUTRACK_RE = re.compile(r"^\s*GPUTRACK:\s*(.+)$", re.MULTILINE)
     _GPUUNTRACK_RE = re.compile(r"^\s*GPUUNTRACK:\s*(.+)$", re.MULTILINE)
     _SENSITIVITY_RE = re.compile(r"^\s*SENSITIVITY:\s*(.+)$", re.MULTILINE)
+    _NORMAL_START_RE = re.compile(r"^\s*NORMAL_START:\s*(.+)$", re.MULTILINE)
 
     @classmethod
     def _extract_directives(cls, text: str):
-        """Pull CALC:/PROMOTE:/GPUTRACK:/GPUUNTRACK:/SENSITIVITY: lines out
-        of an agent response, returning (cleaned_text, calc_exprs,
-        promote_names, gputrack_names, gpuuntrack_names,
-        sensitivity_args). Cleaned text has those lines stripped so they
-        don't clutter what's printed/stored. A bare 'none' value (as
-        instructed for the periodic GPU check-in reply format) is dropped
-        rather than treated as a variable name. sensitivity_args is a list
-        of raw SENSITIVITY: argument strings (usually 0 or 1) -- applied
-        via _cmd_sensitivity(..., quiet=True) same as a manual /sensitivity.
+        """Pull CALC:/PROMOTE:/GPUTRACK:/GPUUNTRACK:/SENSITIVITY:/
+        NORMAL_START: lines out of an agent response, returning
+        (cleaned_text, calc_exprs, promote_names, gputrack_names,
+        gpuuntrack_names, sensitivity_args, normal_start_args). Cleaned
+        text has those lines stripped so they don't clutter what's
+        printed/stored. A bare 'none' value (as instructed for the
+        periodic GPU check-in reply format) is dropped rather than
+        treated as a variable name. sensitivity_args/normal_start_args
+        are lists of raw argument strings (usually 0 or 1) -- applied via
+        _cmd_sensitivity(..., quiet=True) / the NORMAL_START parsing in
+        _apply_directives, same as a manual /sensitivity.
         """
         calc_exprs = [m.strip() for m in cls._CALC_RE.findall(text) if m.strip()]
         promote_names = []
@@ -3476,14 +3793,16 @@ class PulseCLI:
                 n.strip() for n in m.split(",") if n.strip() and n.strip().lower() != "none"
             )
         sensitivity_args = [m.strip() for m in cls._SENSITIVITY_RE.findall(text) if m.strip()]
+        normal_start_args = [m.strip() for m in cls._NORMAL_START_RE.findall(text) if m.strip()]
 
         cleaned = cls._CALC_RE.sub("", text)
         cleaned = cls._PROMOTE_RE.sub("", cleaned)
         cleaned = cls._GPUTRACK_RE.sub("", cleaned)
         cleaned = cls._GPUUNTRACK_RE.sub("", cleaned)
         cleaned = cls._SENSITIVITY_RE.sub("", cleaned)
+        cleaned = cls._NORMAL_START_RE.sub("", cleaned)
         cleaned = re.sub(r"\n{3,}", "\n\n", cleaned).strip()
-        return cleaned, calc_exprs, promote_names, gputrack_names, gpuuntrack_names, sensitivity_args
+        return cleaned, calc_exprs, promote_names, gputrack_names, gpuuntrack_names, sensitivity_args, normal_start_args
 
     def _apply_directives(
         self,
@@ -3492,12 +3811,14 @@ class PulseCLI:
         gputrack_names: Optional[List[str]] = None,
         gpuuntrack_names: Optional[List[str]] = None,
         sensitivity_args: Optional[List[str]] = None,
+        normal_start_args: Optional[List[str]] = None,
     ) -> str:
         """Deterministically compute any CALC: expressions and apply any
-        PROMOTE:/GPUTRACK:/GPUUNTRACK:/SENSITIVITY: requests, returning a
-        short human-readable summary to print and to feed back into the
-        agent's own history (so it sees the verified numbers/state on the
-        next turn instead of trusting its own arithmetic or memory).
+        PROMOTE:/GPUTRACK:/GPUUNTRACK:/SENSITIVITY:/NORMAL_START: requests,
+        returning a short human-readable summary to print and to feed
+        back into the agent's own history (so it sees the verified
+        numbers/state on the next turn instead of trusting its own
+        arithmetic or memory).
         """
         notes = []
 
@@ -3550,6 +3871,33 @@ class PulseCLI:
                 print(f"  🎚 Sensitivity adjusted (agent request): {result}")
                 notes.append(result)
 
+        if normal_start_args:
+            applied = []
+            for raw in normal_start_args:
+                if raw.strip().lower() == "none":
+                    continue
+                for pair in raw.split(","):
+                    pair = pair.strip()
+                    if not pair or "=" not in pair:
+                        continue
+                    name, _, val_str = pair.partition("=")
+                    name = name.strip()
+                    if not name:
+                        continue
+                    try:
+                        val = float(val_str.strip())
+                    except ValueError:
+                        continue
+                    self._normal_start_baselines[name] = val
+                    applied.append(f"{name}={val:.4g}")
+            if applied:
+                print(f"  🌱 Seeded starting baseline (agent estimate, from code): {', '.join(applied)}")
+                notes.append(
+                    f"Seeded expected starting value(s) from the code: {', '.join(applied)}. "
+                    "These act as a spike-detection baseline until real data accumulates, so a "
+                    "genuine explosion in the first few steps can still be caught."
+                )
+
         return "\n\n".join(notes)
 
     _GPU_CHECKIN_PROMPT = (
@@ -3597,7 +3945,7 @@ class PulseCLI:
             # and try again at the next interval.
             cprint(f"[Pulse] ⚠ GPU check-in skipped (agent request failed: {exc})", color=_RED)
             return
-        _, _calc, _promote, gputrack_names, gpuuntrack_names, _sens = self._extract_directives(answer)
+        _, _calc, _promote, gputrack_names, gpuuntrack_names, _sens, _norm = self._extract_directives(answer)
         summary = self._apply_directives([], [], gputrack_names, gpuuntrack_names)
         if summary:
             self.agent_history.append({"role": "user", "content": prompt})
@@ -3815,9 +4163,9 @@ class PulseCLI:
                 raw_analysis = self._call_model(
                     _PASS2_ANALYZE_TMPL.format(regions=regions), max_tokens=700
                 )
-            analysis, calc_exprs, promote_names, gputrack_names, gpuuntrack_names, sensitivity_args = self._extract_directives(raw_analysis)
+            analysis, calc_exprs, promote_names, gputrack_names, gpuuntrack_names, sensitivity_args, normal_start_args = self._extract_directives(raw_analysis)
             print(f"[2] Diagnosis & reasoning\n{analysis}\n")
-            directive_note = self._apply_directives(calc_exprs, promote_names, gputrack_names, gpuuntrack_names, sensitivity_args)
+            directive_note = self._apply_directives(calc_exprs, promote_names, gputrack_names, gpuuntrack_names, sensitivity_args, normal_start_args)
             if directive_note:
                 self.agent_history.append({"role": "user", "content": directive_note})
 
@@ -4455,7 +4803,9 @@ class PulseCLI:
                 self.plateau_range_frac if self.plateau_range_frac is not None
                 else 10 ** (-5 + 3 * s)
             ),
-            # Loose: needs 15/19 directional reversals. Tight: only 6.
+            # Loose: needs 15/18 directional reversals. Tight: only 6.
+            # (A 20-point window yields 19 deltas and only 18 consecutive
+            # delta-pairs to check for a sign flip -- see _check_for_trouble.)
             "oscillation_flip_threshold": (
                 self.oscillation_flip_threshold if self.oscillation_flip_threshold is not None
                 else round(15 - 9 * s)
@@ -4466,6 +4816,26 @@ class PulseCLI:
                 self.oscillation_delta_frac if self.oscillation_delta_frac is not None
                 else 0.10 - 0.08 * s
             ),
+            # Stagnation: has a loss-like variable meaningfully improved
+            # over a LONG window, once normal per-step noise is averaged
+            # out? This is deliberately separate from "plateau" above --
+            # plateau looks at the *range* of the last 20 steps, which a
+            # loss with completely normal noise (bouncing around by, say,
+            # 0.02 every step while never actually trending down) will
+            # never look "flat enough" to trigger, even after a thousand
+            # steps of zero real progress. Stagnation instead compares
+            # the mean of the first quarter of a long window against the
+            # mean of the last quarter, so per-step noise washes out and
+            # only genuine lack of improvement is left.
+            # Loose (s=0): needs 500 steps of history, and even a 0.3%
+            # improvement over that window counts as "still improving".
+            # Tight (s=1): needs only 150 steps, and demands a full 8%
+            # improvement before it stops flagging.
+            "stagnation_window": round(500 - 350 * s),
+            "stagnation_frac": (
+                self.stagnation_frac if self.stagnation_frac is not None
+                else 0.003 + 0.077 * s
+            ),
         }
 
     def _cmd_sensitivity(self, arg: str, quiet: bool = False) -> Optional[str]:
@@ -4486,10 +4856,11 @@ class PulseCLI:
                 f"Sensitivity is {self.sensitivity:.2f} (0=loosest, 1=tightest). Derived thresholds: "
                 f"spike >{th['explosion_multiplier']:.1f}x baseline, "
                 f"plateau range <{th['plateau_range_frac']:.1e} of latest, "
-                f"oscillation >={int(th['oscillation_flip_threshold'])} reversals/19 "
-                f"with avg swing >{th['oscillation_delta_frac']*100:.0f}% of latest. "
+                f"oscillation >={int(th['oscillation_flip_threshold'])} reversals/18 "
+                f"with avg swing >{th['oscillation_delta_frac']*100:.0f}% of latest, "
+                f"stagnation <{th['stagnation_frac']*100:.1f}% improvement over {int(th['stagnation_window'])} steps. "
                 "Usage: /sensitivity <0.0-1.0|loose|medium|tight> or "
-                "/sensitivity <spike|plateau|oscillation> <value|auto>"
+                "/sensitivity <spike|plateau|oscillation|stagnation> <value|auto>"
             )
             if quiet:
                 return msg
@@ -4498,12 +4869,13 @@ class PulseCLI:
 
         parts = arg.split(None, 1)
         sub = parts[0].lower()
-        if sub in ("spike", "plateau", "oscillation") and len(parts) == 2:
+        if sub in ("spike", "plateau", "oscillation", "stagnation") and len(parts) == 2:
             val_str = parts[1].strip().lower()
             field = {
                 "spike": "explosion_multiplier",
                 "plateau": "plateau_range_frac",
                 "oscillation": "oscillation_flip_threshold",  # flips; delta_frac follows the dial
+                "stagnation": "stagnation_frac",  # window length always follows the dial
             }[sub]
             if val_str == "auto":
                 setattr(self, field, None)
@@ -4523,6 +4895,7 @@ class PulseCLI:
         if sub == "reset":
             self.explosion_multiplier = self.plateau_range_frac = None
             self.oscillation_flip_threshold = self.oscillation_delta_frac = None
+            self.stagnation_frac = None
             msg = "✓ Cleared per-signal overrides -- all thresholds now follow the overall dial."
             if quiet:
                 return msg
@@ -4537,7 +4910,7 @@ class PulseCLI:
             except ValueError:
                 msg = (
                     f"Usage: /sensitivity <0.0-1.0|{'|'.join(self._SENSITIVITY_PRESETS)}> or "
-                    "/sensitivity <spike|plateau|oscillation> <value|auto>"
+                    "/sensitivity <spike|plateau|oscillation|stagnation> <value|auto>"
                 )
                 if quiet:
                     return msg
@@ -4565,30 +4938,100 @@ class PulseCLI:
 
             if _looks_like_loss(var_name) and latest is not None:
                 finite_recent = [v for v in hist[-50:] if v is not None and math.isfinite(v)]
-                
-                # Explosion detection
-                if len(finite_recent) >= 5:
-                    baseline = min(finite_recent[:-1])
+
+                # Explosion detection. Normally needs a few real finite
+                # points to compute a "recent minimum" baseline -- which
+                # meant a genuine explosion in the first few steps of
+                # training could never be caught, since there just wasn't
+                # enough history yet to compare against. If the agent has
+                # seeded an expected starting value for this variable from
+                # reading the code (a NORMAL_START: directive, sent
+                # automatically once at the start of training -- see
+                # _apply_directives / _prime_at_start), fold it into the
+                # baseline pool so a step-1 blow-up has something real to
+                # compare against too.
+                seed = self._normal_start_baselines.get(var_name)
+                baseline_pool = finite_recent[:-1] if len(finite_recent) >= 5 else []
+                if seed is not None:
+                    baseline_pool = baseline_pool + [seed]
+                if baseline_pool:
+                    baseline = min(baseline_pool)
                     if baseline > 0 and latest > baseline * th["explosion_multiplier"]:
+                        basis = (
+                            "its expected starting value (estimated from the code)"
+                            if not finite_recent[:-1] else "its recent minimum"
+                        )
                         reasons.append(
                             f"'{var_name}' spiked to {latest:.4g}, "
-                            f"{latest / baseline:.1f}x its recent minimum ({baseline:.4g})"
+                            f"{latest / baseline:.1f}x {basis} ({baseline:.4g})"
                         )
-                
+
                 if len(finite_recent) >= 20:
                     recent_window = finite_recent[-20:]
-                    
+
                     deltas = [recent_window[i] - recent_window[i-1] for i in range(1, len(recent_window))]
-                    
+
+                    # Scale the plateau/oscillation thresholds off the
+                    # window's own typical magnitude (mean |value| across
+                    # all 20 points), not off `latest` alone. `latest` is
+                    # a single sample that can itself land at a momentary
+                    # peak, trough, or near-zero crossing of the very
+                    # curve being judged -- using it as the sole scale
+                    # reference made both checks unreliable: too
+                    # trigger-happy right as a curve crossed zero, too lax
+                    # whenever `latest` happened to be sitting at a local
+                    # extreme instead of a typical value.
+                    scale = sum(abs(v) for v in recent_window) / len(recent_window)
+                    if scale == 0:
+                        scale = abs(latest)  # degenerate all-zero window; fall back rather than lose the check entirely
+
                     window_range = max(recent_window) - min(recent_window)
-                    if window_range < (abs(latest) * th["plateau_range_frac"]) and window_range > 0:
+                    if window_range == 0:
+                        # Identical value for 20 straight steps (dead
+                        # gradient, lr=0, a frozen model) is the most
+                        # extreme plateau there is, not an edge case to
+                        # skip. The old `window_range > 0` guard here
+                        # excluded exactly this, so a totally frozen loss
+                        # -- arguably the easiest plateau to catch -- was
+                        # the one case that could never be flagged.
+                        reasons.append(f"'{var_name}' has completely frozen (identical value for the last 20 steps).")
+                    elif window_range < (scale * th["plateau_range_frac"]):
                         reasons.append(f"'{var_name}' has plateaued (range across last 20 steps is {window_range:.2e}).")
-                    
+
                     sign_flips = sum(1 for i in range(1, len(deltas)) if (deltas[i] * deltas[i-1]) < 0)
                     avg_delta_mag = sum(abs(d) for d in deltas) / len(deltas)
-                    
-                    if sign_flips >= th["oscillation_flip_threshold"] and avg_delta_mag > (abs(latest) * th["oscillation_delta_frac"]):
-                        reasons.append(f"'{var_name}' is heavily oscillating ({sign_flips} directional reversals in 20 steps).")
+
+                    if sign_flips >= th["oscillation_flip_threshold"] and avg_delta_mag > (scale * th["oscillation_delta_frac"]):
+                        reasons.append(f"'{var_name}' is heavily oscillating ({sign_flips} directional reversals in the last 20 steps).")
+
+                # Long-horizon stagnation check -- deliberately separate
+                # from the plateau check above, and computed from its own
+                # independently-sized slice of `hist` (not finite_recent,
+                # which stays capped at 50 so it doesn't change the
+                # explosion baseline's "recent minimum" into a
+                # much-older, possibly stale minimum). Plateau looks at
+                # the *range* of just the last 20 steps, so a loss
+                # bouncing around by completely normal per-step noise
+                # (e.g. +/-0.02 every step, never trending down) will
+                # never look "flat enough" to trip it, no matter how many
+                # hundreds of steps go by with zero real progress --
+                # which is exactly what a loss stuck oscillating in a
+                # narrow band around the same value for 1000+ steps looks
+                # like. This instead compares the mean of the first
+                # quarter of a long window against the mean of the last
+                # quarter, so per-step noise averages out and only
+                # genuine lack of improvement is left standing.
+                window = int(th["stagnation_window"])
+                long_window_raw = [v for v in hist[-window:] if v is not None and math.isfinite(v)]
+                if len(long_window_raw) >= window:
+                    quarter = max(1, window // 4)
+                    early_mean = sum(long_window_raw[:quarter]) / quarter
+                    late_mean = sum(long_window_raw[-quarter:]) / quarter
+                    if early_mean != 0 and abs(early_mean - late_mean) < abs(early_mean) * th["stagnation_frac"]:
+                        reasons.append(
+                            f"'{var_name}' hasn't meaningfully improved over the last {window} steps "
+                            f"(from {early_mean:.4g} to {late_mean:.4g}, despite normal step-to-step noise)."
+                        )
 
         for sub_name, entry in self._matrix_cache.items():
             stats = entry.get("stats", {})
@@ -4596,6 +5039,72 @@ class PulseCLI:
                 reasons.append(f"'{sub_name}' has nan={stats.get('nan')} inf={stats.get('inf')}")
 
         return "; ".join(reasons) if reasons else None
+    _START_PRIME_PROMPT = (
+        "[Automatic start-of-run check -- sent once, automatically, before the first training step, "
+        "so this is your only chance to set these from the code alone, before any real data exists] "
+        "Look at the training code and the tracked variables above. Three things:\n"
+        "1. Judge how noisy this run's loss/metric curves are likely to be, given the model type, "
+        "batch size, learning rate, and loss function, and set an appropriate sensitivity for "
+        "spike/plateau/oscillation detection.\n"
+        "2. For each loss-like tracked variable, estimate its expected value at the very start of "
+        "training from the code alone if you can justify one (e.g. a randomly-initialized N-class "
+        "classifier's cross-entropy loss starts near ln(N); a policy's initial reward is often near "
+        "a known random-policy baseline). This is the ONLY way Pulse can catch a real explosion in "
+        "the first few steps of training -- normally spike detection needs several real data points "
+        "before it has anything to compare against, so a blow-up before then would otherwise go "
+        "completely undetected.\n"
+        "3. Identify any critical variables -- e.g. loss, or core tensors that live exclusively in "
+        "GPU memory -- that are worth the closer, GPU-synced look from step one, to catch memory "
+        "spikes or numerical instability early rather than after they've already caused visible "
+        "damage.\n\n"
+        "Reply with ONLY these three lines, in exactly this format, and nothing else -- no diagnosis, "
+        "no prose:\n"
+        "SENSITIVITY: <0.0-1.0, a preset (loose/medium/tight), or 'spike|plateau|oscillation <value|auto>'>\n"
+        "NORMAL_START: <comma-separated var=value pairs for loss-like tracked variables you can justify, or 'none'>\n"
+        "GPUTRACK: <comma-separated variable names to track closely from the start, or 'none'>"
+    )
+
+    def _prime_at_start(self) -> None:
+        """Ask the agent, once, automatically, before the very first
+        training step, to (a) set a sensitivity appropriate to this run's
+        code, (b) estimate a starting-value baseline for loss-like tracked
+        variables by reading the code alone (a NORMAL_START: directive --
+        see _apply_directives), and (c) flag any variables worth GPU-level
+        tracking from step one (a GPUTRACK: directive).
+
+        All three of these used to only ever happen reactively: sensitivity
+        only got tuned once the agent had already seen live data (e.g. a
+        GPU check-in or a manual /ask), GPU-tracking only ever got turned
+        on after something had already looked suspicious enough to ask
+        about, and there was no mechanism at all for seeding a starting
+        baseline -- which meant an explosion in the first few steps of
+        training, before 5 real data points existed, could never be
+        caught (see _check_for_trouble). Doing all three once up front,
+        from the code alone, closes those gaps before training even
+        starts.
+
+        Best-effort and silent on failure -- this must never be the thing
+        that makes a training run fail to start. Runs at most once per
+        process (guarded by self._start_primed), and only if an agent
+        provider/key is actually configured and the training code was
+        made available via set_code_text.
+        """
+        if self._start_primed:
+            return
+        self._start_primed = True
+        if not self.agent_provider or not self.agent_key or not self.code_text:
+            return
+        try:
+            context = self._build_agent_context(include_code=True)
+            answer = self._call_model(f"{context}\n\n{self._START_PRIME_PROMPT}", max_tokens=300)
+        except AgentRequestFailed as exc:
+            cprint(f"[Pulse] ⚠ Start-of-run sensitivity check skipped (agent request failed: {exc})", color=_YELLOW)
+            return
+        _, _calc, _promote, gputrack_names, _gpuu, sensitivity_args, normal_start_args = self._extract_directives(answer)
+        summary = self._apply_directives([], [], gputrack_names, None, sensitivity_args, normal_start_args)
+        if summary:
+            cprint(f"[Pulse] Start-of-run check: {summary}", color=_YELLOW)
+
     def update(self, step: Optional[int] = None, generate_pdfs: Optional[bool] = None) -> None:
         """Called at every training step/checkpoint.
 
@@ -4622,6 +5131,8 @@ class PulseCLI:
         loss_var = next((v for v in self.tracked_vars if _looks_like_loss(v)), None)
         new_loss_value: Optional[float] = None
 
+        self._prime_at_start()
+
         # Uptime: wall-clock time since the *previous* update() call handed
         # control back to the training loop, i.e. time actually spent in
         # the user's own training code (forward/backward/optimizer step).
@@ -5032,6 +5543,9 @@ class PulseCLI:
             if cmd.lower().startswith("/deleteaccount"):
                 self._cmd_deleteaccount(cmd[14:].strip())
                 continue
+            if cmd.lower() == "/logout":
+                self._cmd_logout("")
+                continue
             if cmd.lower().startswith("/commit"):
                 self._cmd_commit(cmd[7:].strip())
                 continue

{pulseml-0.2.0 → pulseml-0.2.2}/src/pulse/pulse_supabase.py

@@ -191,6 +191,17 @@ class SupabaseError(Exception):
     pass
 
 
+class SupabaseEmailConfirmationRequired(SupabaseError):
+    """Raised by sign_up() when the account was actually created but this
+    project's Auth settings require the user to confirm their email
+    before a session can be issued. A subclass of SupabaseError (not a
+    separate flag) so any existing `except SupabaseError` call site keeps
+    working unchanged, while a call site that wants to show a "go check
+    your email" message instead of a generic "sign up failed" message can
+    catch this specifically."""
+    pass
+
+
 # ----------------------------------------------------------------------------
 # Auth session state -- the real Supabase Auth JWT for the signed-in user,
 # as distinct from the app-level "session_token"/session_token_hash pair
@@ -602,7 +613,7 @@ def sign_up(email: str, password: str, plan: Optional[str] = None) -> Dict[str,
     Returns the user profile from the profiles table."""
     if not is_valid_email(email):
         raise SupabaseError(
-            "Emails must be greater than 8 characters: letters, numbers, underscores, and hyphens only."
+            "Enter a valid email address (min. 8 characters), e.g. name@example.com."
         )
     if len(password) < 8:
         raise SupabaseError("Password must be at least 8 characters.")
@@ -644,8 +655,8 @@ def sign_up(email: str, password: str, plan: Optional[str] = None) -> Dict[str,
         # user confirms their email and logs in for real -- surface that
         # plainly instead of the misleading "profile was not created"
         # below (which is what happens if you try to fetch it anyway).
-        raise SupabaseError(
-            "Account created -- check your email to confirm your address, then log in."
+        raise SupabaseEmailConfirmationRequired(
+            "Confirm your account: check your email for a confirmation link, then log in."
         )
 
     # Authenticate every subsequent request in this process (starting with
@@ -1225,6 +1236,41 @@ def fetch_recent_sessions(
         return _request("GET", "Debug_Sessions", params=params, timeout=_TIMEOUT_INTERACTIVE) or []
 
 
+def fetch_debug_session(session_id: str) -> Optional[Dict[str, Any]]:
+    """Fetch a single Debug_Sessions row by id (fields still
+    compressed -- caller decodes with decode_entries).
+
+    Used when resuming an EXISTING debug session -- currently only after
+    an auto-fix restart, which carries the same session id into the new
+    process via PULSE_AUTO_SESSION_ID -- so the resumed process can
+    preload its local agent_logs/error_tracebacks/telemetry/incidents
+    lists with whatever's already saved server-side. Without this, a
+    freshly-started process's lists start empty and, since a PATCH
+    replaces the whole array column (PostgREST has no array "append"
+    verb -- see _build_cloud_patch_body), its very first flush after
+    the restart would silently overwrite the pre-restart history with
+    just the handful of entries logged since. Falls back to the legacy
+    select list for deployments that don't have the incidents/uptime/
+    downtime columns yet.
+    """
+    try:
+        rows = _request(
+            "GET", "Debug_Sessions",
+            params={"id": f"eq.{session_id}", "select": _SESSION_SELECT},
+        )
+    except SupabaseError:
+        try:
+            rows = _request(
+                "GET", "Debug_Sessions",
+                params={"id": f"eq.{session_id}", "select": _SESSION_SELECT_LEGACY},
+            )
+        except SupabaseError:
+            return None
+    if not rows:
+        return None
+    return rows[0]
+
+
 def patch_debug_session(session_id: str, fields: Dict[str, Any], timeout: float = _TIMEOUT_BACKGROUND) -> None:
     _request(
         "PATCH", "Debug_Sessions",

{pulseml-0.2.0 → pulseml-0.2.2}/src/pulseml.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulseml
-Version: 0.2.0
+Version: 0.2.2
 Summary: A live ML training debugger - GUI or CLI, any backend (NumPy, PyTorch, TensorFlow, CuPy, JAX).
 Author-email: Yash Patel <codeyash09@gmail.com>
 License: Proprietary