Merge branch 'worktree-mobile-redesign'

Author: rsamf

CLAUDE.md

@@ -395,7 +395,7 @@ Smoothed values are rendered, not persisted: raw entries in the store remain unt
 
 ### Alerts (code-fired + condition rules)
 
-`nb.alert(title, text, level)` fires a webhook (if configured) and emits an `alert` wire event stamped `triggered_by: "code"`; the daemon appends it to `run.alerts`. **Alert rules** are set without code changes (`nebo alerts set --condition "train/loss > 5"`, MCP `nebo_set_alert`): they live in `DaemonState.alert_rules` (in-memory) and are evaluated in `_process_event`'s metric branch (`_evaluate_alert_rules`) against numeric metric values only. A rule fires at most once per run; the fired alert lands in `run.alerts` with `triggered_by: "cli"` plus a `condition` display string (and is cache-persisted via `_fire_rule_alert`), so `/runs/{id}/alerts/wait` (`nebo runs wait`, `nebo_wait_for_alert`) wakes on it with no extra wiring. Rule CRUD: `GET/POST /alerts`, `GET/DELETE /alerts/{id}`; condition strings (`<metric> <op> <number>`) are parsed by `nebo/client.py:parse_condition`. The metric name `last_event` is **reserved for heartbeat rules** (`"last_event > 60"` = fire once the run has been idle 60 s — nebo's run-completion signal): evaluated by an always-on ~1 s lifespan task (`evaluate_heartbeat_rules`, `HEARTBEAT_TICK_S`) that notifies `_event_notify` itself (a quiet run has no ingest to wake waiters); ops `>`/`>=` only, no `loggable_id`; run-scoped rules fall back to the cache for RAM-evicted runs and fire immediately for already-idle runs, global rules skip runs whose last activity predates the rule. File-mode `alert` entries are intentionally **not** in `ENTRY_TYPES` (byte 255); the watcher's payload-type recovery ingests them — don't make the type byte authoritative.
+`nb.alert(title, text, level)` fires a webhook (if configured) and emits an `alert` wire event stamped `triggered_by: "code"`; the daemon appends it to `run.alerts`. **Alert rules** are set without code changes (`nebo alerts set --condition "train/loss > 5"`, MCP `nebo_set_alert`): they live in `DaemonState.alert_rules` (in-memory) and are evaluated in `_process_event`'s metric branch (`_evaluate_alert_rules`) against numeric metric values only. A rule fires at most once per run; the fired alert lands in `run.alerts` with `triggered_by: "cli"` plus a `condition` display string (and is cache-persisted via `_fire_rule_alert`), so `/runs/{id}/alerts/wait` (`nebo runs wait`, `nebo_wait_for_alert`) wakes on it with no extra wiring. Rule CRUD: `GET/POST /alerts`, `GET/DELETE /alerts/{id}`; condition strings (`<metric> <op> <number>`) are parsed by `nebo/client.py:parse_condition`. `GET /runs/{id}/alerts` lists one run's fired alerts (code- and rule-fired) — the mobile alerts sheet hydrates from it, and live `alert` WS events append to the store's per-run `alerts` slice. The metric name `last_event` is **reserved for heartbeat rules** (`"last_event > 60"` = fire once the run has been idle 60 s — nebo's run-completion signal): evaluated by an always-on ~1 s lifespan task (`evaluate_heartbeat_rules`, `HEARTBEAT_TICK_S`) that notifies `_event_notify` itself (a quiet run has no ingest to wake waiters); ops `>`/`>=` only, no `loggable_id`; run-scoped rules fall back to the cache for RAM-evicted runs and fire immediately for already-idle runs, global rules skip runs whose last activity predates the rule. File-mode `alert` entries are intentionally **not** in `ENTRY_TYPES` (byte 255); the watcher's payload-type recovery ingests them — don't make the type byte authoritative.
 
 ### Global state singleton
 
@@ -419,6 +419,8 @@ Smoothed values are rendered, not persisted: raw entries in the store remain unt
 
 React 19 + Vite 7 + TypeScript + Tailwind v4 + shadcn-style components. State via `zustand` (`src/store/index.ts`). WebSocket handled in `src/hooks/useWebSocket.ts`, connecting to the daemon's `/stream` endpoint. Graph rendering uses `@xyflow/react` with `@dagrejs/dagre` layout (`src/components/graph/DagGraph.tsx`). Metrics charts use **Chart.js 4** (registered in `src/components/charts/registerChartJs.ts`) with `chartjs-plugin-zoom` for pan/zoom; the shared lifecycle hook is `src/components/charts/useChartJs.ts`. The bottom panel is the **Tracker** (`src/components/timeline/`); see "Tracker" under the Metrics model section. The default view is "Flat" (store key `'flat'`, wire value `nb.ui(view="flat")`); the DAG view is opt-in. The `@/` import alias maps to `ui/src/`. shadcn registry is configured via `.mcp.json` (the `shadcn` MCP server).
 
+**Mobile experience** (`src/components/mobile/`, <768px via `useIsDesktop`): a dedicated touch UI rendered by `MobileApp` from App.tsx's mobile branch — the desktop layout is untouched. Screens: `MobileRunList` (uniform cards; group tap opens the group page; the search field segues to a flat search screen) → `MobileRunView` (header: group crumb / title → `MobileRunInfoSheet` with notes + config + copyable identifiers; bell → `MobileAlertsSheet`, severity-filterable, tap jumps to the node sheet; gear → `MobileSettingsSheet` sliders over the shared `Settings` keys). Body toggles DAG ⇄ Feed via the shared `viewMode` store key ('graph'/'flat', so `nb.ui(view=)` still applies): `MobileDagCanvas` is a custom dagre + pan/pinch canvas (not ReactFlow; no explicit `setPointerCapture` — it would retarget the derived click and swallow node taps), `MobileFeed` is a stage-rail + type-filter card feed whose expanded charts reuse `SingleRunChart` (exported from `NodeMetrics`). `MobileTracker` renders the persistent heat-strip bar + scrub sheet over `useStreams`. Node taps and alerts open `MobileNodeSheet`, which wraps the desktop `LoggableTabContainer` for full tab parity. Store invariant: **every run mutator clones the run object** (`runs.set(id, { ...run, field })` — see the comment above `setRuns`), so `s.runs.get(id)` selectors are sound and fire only for that run; never mutate a stored run in place. Components that read one slice should select the leaf field (`s.runs.get(id)?.logs`) so unrelated mutations don't re-render them. Phone-width embeds (`?run=`, `&dag`, `&flat`) render the mobile layout via `EmbeddedMobileLayout`.
+
 ### Tests
 
 Plain `pytest` + `pytest-asyncio`. Tests are self-contained and exercise the public surface (`test_decorators.py`, `test_client.py`, `test_daemon.py`, `test_mcp_tools.py`, `test_fileformat.py`, …). There is no separate lint/type-check step in CI — only the pytest matrix in `.github/workflows/ci.yml`.

nebo/server/daemon.py

@@ -1881,6 +1881,16 @@ async def get_run_audio(run_id: str):
             return JSONResponse(status_code=404, content={"error": f"Run '{run_id}' not found"})
         return {"audio": audio}
 
+    @app.get("/runs/{run_id}/alerts")
+    async def get_run_alerts(run_id: str):
+        """Fired alerts for one run — both code-fired (`nb.alert`) and
+        rule-fired (`triggered_by: "cli"`) entries, in firing order."""
+        await state.ensure_deep(run_id)
+        alerts = state.run_alerts(run_id)
+        if alerts is None:
+            return JSONResponse(status_code=404, content={"error": f"Run '{run_id}' not found"})
+        return {"alerts": alerts}
+
     @app.get("/runs/{run_id}/media/{media_id}")
     async def get_media(run_id: str, media_id: str, request: Request):
         await state.ensure_deep(run_id)

tests/test_daemon.py

@@ -805,6 +805,16 @@ def test_alert_event_is_appended_to_run():
     assert run.alerts[0]["level_name"] == "WARN"
     assert run.alerts[0]["loggable_id"] == "node_a"
 
+    # The per-run listing endpoint returns the same fired alerts.
+    resp = client.get("/runs/r_alert_1/alerts")
+    assert resp.status_code == 200
+    alerts = resp.json()["alerts"]
+    assert len(alerts) == 1
+    assert alerts[0]["title"] == "Loss went up"
+
+    resp = client.get("/runs/no_such_run/alerts")
+    assert resp.status_code == 404
+
 
 def test_alerts_wait_returns_alert():
     """Wait endpoint should unblock and return alert when one arrives at or above min_level."""