feat: named text streams, canonical nebo:// refs, and UI/perf work

Implements the NEW.md batch. The through-line is that text becomes a
first-class named stream like metrics and media, and every resource gets
an unambiguous, clickable identifier.

Text redesign (breaking):
- nb.log(message, name=) -> nb.log_text(name, message, step=), with name
  a required first positional, matching the metric helpers. There is no
  level/severity anywhere; the old info/warn/error UI was dead code for
  every SDK-produced run. nb.log() survives only as a deprecated shim
  that forwards and warns once per process.
- Wire/file type is now "text" (entry code 9). The legacy "log" spelling
  (code 0) stays readable forever: ingest normalizes it, so existing
  .nebo files decode unchanged.
- Renamed through every surface: /runs/{id}/text, `nebo text ls`,
  nebo_get_text, cache table `texts` (schema v6), ?text=NAME embeds.
- Text renders like images: one card per stream name, each entry a
  header row (name, step, timestamp, actions) over the payload.

Canonical nebo:// references:
- nebo://run/<id>[/<loggable>[/<name...>]][@<step>] and
  nebo://group/<path>, parsed by twin implementations in
  nebo/core/refs.py and ui/src/lib/refs.ts. The loggable is always one
  segment, so stream names containing '/' need no escaping.
- Deep links navigate deterministically: force the flat view, open the
  tab/filter owning the card, scroll to it, flash it for 3s. Shared
  modality order keeps desktop and mobile in lockstep.
- New GET /resolve?ref= returns parsed components plus existence.
- @nb.fn now guarantees unique loggable ids: two different functions
  claiming the same qualname no longer merge into one node.

Performance (a 112 MB / 858k-point run opened slowly):
- GET /runs/{id}/metrics decimates per series (min/max buckets, ~2k
  points, ?points=0 for full) and reports total_points/downsampled.
  The UI paints the decimated response, then fetches full fidelity so
  every datapoint still reaches the user.
- Watcher deepening no longer broadcasts a file's whole history over
  WebSocket, ingest yields between slices, and the store pools metric
  appends per series per batch.
- Measured: /metrics 69.7 MB -> 5.2 MB, warm read 6.9s -> 0.77s.

UI:
- DAG auto-layout fixes on desktop and the mobile canvas (links to a run
  could render unlaid-out), horizontal desktop default, solid edges, no
  pane context menu.
- Right panel hosts Markdown / Config / Settings as icon tabs, open by
  default and resizable; config renders as a structured tree.
- Top bar reduced to <group>/<name> <id> <date>.
- Groups only expand in the tree; their docs are tree leaves opening a
  dedicated viewer. No client-side run rename; tooltips drop counts that
  read 0 for shallow runs.
- Tracker: step navigation works while collapsed, modality chips moved
  under the stream search, collapsed branches merge their datapoints.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XrJfA61nnwkwJ86UiSvYYN

Author: rsamf

CLAUDE.md

@@ -48,7 +48,7 @@ Agent skills are released in the package preparing coding agents to not only wri
 
 ```mermaid
 graph LR
-    A[Your Python Pipeline] --> B[Nebo SDK<br>@fn, log, track, ...]
+    A[Your Python Pipeline] --> B[Nebo SDK<br>@fn, log_text, track, ...]
     B --> C[Daemon Server<br>FastAPI, port 7861]
     B --> D[Terminal Dashboard<br>Rich]
     C --> E[CLI<br>nebo]

README.md

@@ -8,7 +8,7 @@ subcommands:
 
 * **Server & admin** — start/stop the daemon, manage its cache, install
   agent skills, deploy to a Hugging Face Space.
-* **Agent-callable Q&A and writes** — read runs, logs, metrics, and the
+* **Agent-callable Q&A and writes** — read runs, text, metrics, and the
   DAG from a running daemon, manage alert rules, and push new entries
   into a run. These are the same commands the shipped agent skills use.
 
@@ -401,9 +401,11 @@ env var; reorganize afterward from here. Each group can hold markdown docs
 {run_id: group}}`` (runs absent from ``runs`` are at the root).
 ``groups rm`` refuses if the group still has member runs or subgroups —
 move them out first (nebo has no run deletion). Group docs support
-``nebo://run/<id>``, ``nebo://run/<id>?step=<n>``, and
-``nebo://group/<path>`` deep links that the web UI turns into clickable
-navigation.
+canonical ``nebo://`` references — ``nebo://run/<id>``,
+``nebo://run/<id>/<loggable>/<stream>``, any run form suffixed with
+``@<step>``, and ``nebo://group/<path>`` — that the web UI turns into
+clickable navigation (``?step=<n>`` is still accepted as a legacy
+alias).
 
 nebo graph
 ==========
@@ -421,7 +423,8 @@ nebo loggables
 
 .. option:: show <loggable_id> [--run <run_id>]
 
-    Show a loggable's status: metadata, recent logs, metrics, progress.
+    Show a loggable's status: metadata, recent text entries, metrics,
+    progress.
     Loggables are ``@nb.fn`` node ids (function qualnames), plus the
     implicit ``__global__`` and ``__agent__`` loggables.
 
@@ -437,22 +440,24 @@ docstrings.
 
     Run id (latest if omitted).
 
-nebo logs
-=========
+nebo text (read)
+================
 
-.. program:: nebo logs
+.. program:: nebo text ls
 
-.. option:: --run <run_id>
-
-    Run ID (latest if omitted).
+.. code-block:: bash
 
-.. option:: --node <loggable_id>
+    nebo text ls
+    nebo text ls --run run_1748_0 --node train --limit 50
 
-    Filter to one loggable.
+.. option:: ls [--run <run_id>] [--node <loggable_id>] [--limit <n>]
 
-.. option:: --limit <n>
+    List text entries, newest last. Human output prints one line per
+    entry as ``[loggable_id] name@step: message``.
 
-    Maximum entries to return (default: ``100``).
+    * ``--run`` — run ID (latest if omitted).
+    * ``--node`` — filter to one loggable.
+    * ``--limit`` — maximum entries to return (default: ``100``).
 
 nebo metrics (read)
 ===================
@@ -569,15 +574,15 @@ nebo text / images / audio log
 
 .. code-block:: bash
 
-    nebo text log --entries-json '[{"message": "analysis complete"}]'
+    nebo text log --entries-json '[{"name": "analysis", "message": "analysis complete"}]'
     nebo images log --entries-json '[{"name": "annotated", "path": "./out.png"}]'
     nebo audio log --entries-json '[{"name": "sample", "path": "./clip.wav", "sr": 22050}]'
 
 .. option:: --entries-json <json>
 
     JSON list of entries.
 
-    * **text**: ``{loggable_id?, message, name?, level?, step?}``
+    * **text**: ``{loggable_id?, name?, message, step?}``
     * **images**: ``{loggable_id?, name, path? | url? | data?, step?,
       labels?}`` — exactly one of ``path`` (local file, read and
       encoded by the CLI), ``url`` (fetched server-side), or ``data``

docs/cli.rst

@@ -4,13 +4,13 @@
 @nb.fn()
 def setup():
     """Initialize shared resources."""
-    nb.log("Setting up")
+    nb.log_text("status", "Setting up")
 
 
 @nb.fn(depends_on=[setup])
 def process():
     """Uses resources initialized by setup."""
-    nb.log("Processing")
+    nb.log_text("status", "Processing")
 
 
 setup()

docs/demos/guide/11_depends_on.py

@@ -4,15 +4,15 @@
 @nb.fn()
 class DataPipeline:
     def load(self):
-        nb.log("Loading data")
+        nb.log_text("status", "Loading data")
         return [1, 2, 3]
 
     def transform(self, data):
-        nb.log(f"Transforming {len(data)} items")
+        nb.log_text("status", f"Transforming {len(data)} items")
         return [x * 2 for x in data]
 
     def save(self, data):
-        nb.log(f"Saving {len(data)} items")
+        nb.log_text("status", f"Saving {len(data)} items")
 
 
 p = DataPipeline()

docs/demos/guide/12_class_grouping.py

@@ -10,7 +10,7 @@
 
 @nb.fn()
 def classify():
-    nb.log("Classifying images")
+    nb.log_text("status", "Classifying images")
     nb.log_line("accuracy", 0.92)
 
 

docs/demos/guide/13_workflow_md.py

@@ -5,13 +5,13 @@
 
 @nb.fn(ui={"color": "#fb923c"})
 def data_loader():
-    nb.log("Loading data")
+    nb.log_text("status", "Loading data")
     return [1, 2, 3]
 
 
 @nb.fn(ui={"color": "#34d399", "default_tab": "metrics"})
 def train(data):
-    nb.log(f"Training on {len(data)} items")
+    nb.log_text("status", f"Training on {len(data)} items")
     for step in range(20):
         nb.log_line("loss", 1.0 / (step + 1))
 

docs/demos/guide/14_ui_hints.py

@@ -11,7 +11,7 @@ def generate(num_samples: int = 200, noise: float = 0.1, seed: int = 42):
     rng = np.random.default_rng(seed)
     t = np.linspace(0, 4 * np.pi, num_samples)
     signal = np.sin(t) + noise * rng.standard_normal(num_samples)
-    nb.log(f"Generated {num_samples} samples")
+    nb.log_text("status", f"Generated {num_samples} samples")
     return signal
 
 
@@ -22,14 +22,14 @@ def normalize(data, method: str = "standard", clip_min: float = -3.0, clip_max:
     if method == "standard":
         data = (data - data.mean()) / (data.std() + 1e-8)
     data = np.clip(data, clip_min, clip_max)
-    nb.log(f"Normalized with method={method}")
+    nb.log_text("status", f"Normalized with method={method}")
     return data
 
 
 @nb.fn()
 def analyze(data):
     """Compute statistics on the processed data."""
-    nb.log(f"Stats: mean={data.mean():.4f}, std={data.std():.4f}")
+    nb.log_text("stats", f"Stats: mean={data.mean():.4f}, std={data.std():.4f}")
     nb.log_line("mean", float(data.mean()))
     nb.log_line("std", float(data.std()))
     return {"mean": float(data.mean()), "std": float(data.std()), "n": len(data)}

docs/demos/guide/15_complete_pipeline.py

@@ -1,9 +1,9 @@
 import numpy as np
 import nebo as nb
 
-nb.log("Starting training...")
+nb.log_text("status", "Starting training...")
 for epoch in range(3):
     loss = 1.0 / (epoch + 1)
-    nb.log(f"Epoch {epoch}: loss={loss:.4f}")
+    nb.log_text("epochs", f"Epoch {epoch}: loss={loss:.4f}")
 
-nb.log(np.random.default_rng(0).standard_normal((32, 64)))
+nb.log_text("weights", np.random.default_rng(0).standard_normal((32, 64)))

docs/demos/guide/1_text_logs.py

@@ -1,6 +1,6 @@
 import nebo as nb
 
-nb.log("environment looks good")
+nb.log_text("status", "environment looks good")
 nb.log_line("warmup_heartbeat", 1.0)
 nb.log_line("warmup_heartbeat", 1.0)
 nb.log_line("warmup_heartbeat", 1.0)