feat: rebuild Slipstream Lab as technical companion

Replace the old landing-page-style demo with a CPU-first protocol lab focused on UCR exploration, conformance inspection, LangGraph snippets, and training guidance.

README.md

@@ -1,42 +1,45 @@
 ---
-title: Slipstream v3
-emoji: ⚡
-colorFrom: blue
-colorTo: purple
+title: Slipstream Lab
+emoji: 🧭
+colorFrom: yellow
+colorTo: gray
 sdk: gradio
-sdk_version: 5.12.0
+sdk_version: 6.5.1
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: "Real-time semantic quantization for multi-agent AI"
+short_description: "CPU-first technical companion for Slipstream 3.1.1"
 ---
 
-# Slipstream v3: Real-Time Semantic Quantization
+# Slipstream Lab
 
-Type a natural language sentence and watch it get quantized into a factorized
-Force-Object wire message in real time. No API keys, no GPU.
+Technical companion Space for Slipstream `3.1.1`.
 
-## Features
+This Space is intentionally different from [slipstream.making-minds.ai](https://slipstream.making-minds.ai):
 
-- **Quantize** -- type any sentence, see the TQT (Think-Quantize-Transmit) pipeline in action
-- **Encode** -- build wire messages manually from Force + Object dropdowns
-- **Decode** -- parse and inspect SLIP v3 wire messages
-- **UCR Explorer** -- browse all 45 core anchors with filtering
+- the website explains and promotes the release
+- this Space helps engineers inspect the shipped protocol and adoption path
+
+## Tabs
+
+- `Overview`: release metrics and links
+- `UCR Explorer`: browse the 45 core anchors
+- `Conformance Lab`: validate and parse real `SLIP v3` wires
+- `LangGraph Starter`: copy-paste integration snippets
+- `Dataset / Model`: understand when training is optional and when it helps
+
+## Runtime model
+
+- CPU-first
+- ZeroGPU-compatible
+- no live model inference
+- no training workflow
 
 ## Resources
 
-- **GitHub**: [github.com/anthony-maio/slipcore](https://github.com/anthony-maio/slipcore)
-- **PyPI**: `pip install slipcore`
-- **Paper**: [doi.org/10.5281/zenodo.18063451](https://doi.org/10.5281/zenodo.18063451)
-- **SDK Guide**: [docs/sdk-guide.md](https://github.com/anthony-maio/slipcore/blob/master/docs/sdk-guide.md)
-
-## Citation
-
-```bibtex
-@misc{maio2025slipstream,
-  title={Slipstream: Semantic Quantization for Efficient Multi-Agent Coordination},
-  author={Maio, Anthony},
-  year={2025},
-  doi={10.5281/zenodo.18063451}
-}
-```
+- Website: [slipstream.making-minds.ai](https://slipstream.making-minds.ai)
+- GitHub: [anthony-maio/slipcore](https://github.com/anthony-maio/slipcore)
+- PyPI: [slipcore](https://pypi.org/project/slipcore/)
+- Paper: [doi.org/10.5281/zenodo.18063451](https://doi.org/10.5281/zenodo.18063451)
+- Dataset: [anthonym21/slipstream-tqt](https://huggingface.co/datasets/anthonym21/slipstream-tqt)
+- Reference model: [anthonym21/slipstream-glm-z1-9b](https://huggingface.co/anthonym21/slipstream-glm-z1-9b)

app.py

@@ -1,523 +1,431 @@
-"""
-Slipstream v3: Real-Time Semantic Quantization Demo
-Interactive HuggingFace Space for multi-agent AI communication protocol.
-"""
-
-import gradio as gr
-
-from slipcore import (
-    KeywordQuantizer,
-    create_base_ucr,
-    format_fallback,
-    format_slip,
-    parse_slip,
-    render_human,
-    __version__,
-)
-from slipcore.quantizer import FORCE_KEYWORDS, OBJECT_KEYWORDS, _keyword_score
-
-# --------------------------------------------------------------------------
-# Shared state
-# --------------------------------------------------------------------------
-
-UCR = create_base_ucr()
-QUANTIZER = KeywordQuantizer()
-
-FORCES = [
-    "Observe", "Inform", "Ask", "Request", "Propose", "Commit",
-    "Eval", "Meta", "Accept", "Reject", "Error", "Fallback",
-]
-
-OBJECTS = [
-    "State", "Change", "Error", "Result", "Status", "Complete",
-    "Blocked", "Progress", "Clarify", "Permission", "Resource",
-    "Task", "Plan", "Review", "Help", "Cancel", "Priority",
-    "Alternative", "Rollback", "Deadline", "Approve", "NeedsWork",
-    "Ack", "Sync", "Handoff", "Escalate", "Abort", "Condition",
-    "Defer", "Timeout", "Validation", "Generic",
-]
-
-FORCE_DESCRIPTIONS = {
-    "Observe": "Passively notice state, change, or error",
-    "Inform": "Report information -- status, completion, blockage, progress",
-    "Ask": "Seek information -- clarification, status, permission",
-    "Request": "Direct action -- task, review, help, plan",
-    "Propose": "Suggest something -- plan, change, alternative",
-    "Commit": "Pledge to something -- task, deadline, resource",
-    "Eval": "Judge work quality -- approve, needs work",
-    "Meta": "Protocol-level -- acknowledge, sync, handoff, escalate",
-    "Accept": "Agree to a proposal or request",
-    "Reject": "Decline a proposal or request",
-    "Error": "Report system error -- timeout, resource, permission",
-    "Fallback": "Content too complex for standard quantization",
-}
-
-FORCE_COLORS = {
-    "Observe": "#6366f1",   # indigo
-    "Inform": "#0ea5e9",    # sky
-    "Ask": "#f59e0b",       # amber
-    "Request": "#ef4444",   # red
-    "Propose": "#8b5cf6",   # violet
-    "Commit": "#22c55e",    # green
-    "Eval": "#14b8a6",      # teal
-    "Meta": "#64748b",      # slate
-    "Accept": "#10b981",    # emerald
-    "Reject": "#f43f5e",    # rose
-    "Error": "#dc2626",     # red-600
-    "Fallback": "#78716c",  # stone
-}
-
-
-# --------------------------------------------------------------------------
-# Quantize tab logic
-# --------------------------------------------------------------------------
-
-def quantize_sentence(text: str, src: str, dst: str) -> str:
-    """Quantize natural language into SLIP v3, showing the full TQT pipeline."""
-    if not text.strip():
-        return ""
-
-    src = "".join(c for c in (src or "alice").strip() if c.isalnum())[:20] or "alice"
-    dst = "".join(c for c in (dst or "bob").strip() if c.isalnum())[:20] or "bob"
-
-    # Run quantizer
-    result = QUANTIZER.quantize(text)
-    force = result.force
-    obj = result.obj
-    confidence = result.confidence
-
-    # Build wire
-    if result.is_fallback:
-        ref = QUANTIZER.fallback_store.store(text)
-        wire = format_fallback(src, dst, ref)
-    else:
-        wire = format_slip(src, dst, force, obj)
-
-    # Get canonical from UCR
-    anchor = UCR.get_by_force_obj(force, obj)
-    canonical = anchor.canonical if anchor else f"{force} {obj}"
-
-    # Compute keyword match details for Force
-    force_detail_rows = []
-    for f_name, patterns in FORCE_KEYWORDS.items():
-        score = _keyword_score(text, patterns)
-        if score > 0:
-            matched = [p for p in patterns if p.lower() in text.lower()]
-            color = FORCE_COLORS.get(f_name, "#666")
-            bar_width = int(score * 100)
-            winner = " **<--**" if f_name == force else ""
-            force_detail_rows.append(
-                (score, f"| <span style='color:{color}'>`{f_name}`</span> | "
-                 f"{''.join(matched[:3])} | "
-                 f"<span style='display:inline-block;background:{color};width:{bar_width}px;height:12px;border-radius:3px'></span> "
-                 f"{score:.2f}{winner} |")
-            )
-    force_detail_rows.sort(key=lambda x: x[0], reverse=True)
-
-    # Compute keyword match details for Object
-    obj_detail_rows = []
-    for o_name, patterns in OBJECT_KEYWORDS.items():
-        score = _keyword_score(text, patterns)
-        if score > 0:
-            matched = [p for p in patterns if p.lower() in text.lower()]
-            bar_width = int(score * 100)
-            winner = " **<--**" if o_name == obj else ""
-            obj_detail_rows.append(
-                (score, f"| `{o_name}` | "
-                 f"{''.join(matched[:3])} | "
-                 f"<span style='display:inline-block;background:#6366f1;width:{bar_width}px;height:12px;border-radius:3px'></span> "
-                 f"{score:.2f}{winner} |")
-            )
-    obj_detail_rows.sort(key=lambda x: x[0], reverse=True)
-
-    # Token comparison
-    input_tokens = len(text.split())
-    wire_tokens = len(wire.split())
-    reduction = ((input_tokens - wire_tokens) / input_tokens * 100) if input_tokens > 0 else 0
-
-    # Confidence color
-    if confidence >= 0.6:
-        conf_color = "#22c55e"
-        conf_label = "High"
-    elif confidence >= 0.3:
-        conf_color = "#f59e0b"
-        conf_label = "Medium"
-    else:
-        conf_color = "#ef4444"
-        conf_label = "Low"
-
-    force_color = FORCE_COLORS.get(force, "#666")
-
-    # Build output
-    out = []
-
-    # Wire result (hero)
-    out.append(f"### Wire Output")
-    out.append(f"```")
-    out.append(wire)
-    out.append(f"```")
-    out.append("")
-
-    # Human-readable
-    human = render_human(wire)
-    out.append(f"> {human}")
-    out.append("")
-
-    # Confidence + token savings
-    conf_bar_width = int(confidence * 200)
-    out.append(f"| Metric | Value |")
-    out.append(f"|--------|-------|")
-    out.append(f"| Confidence | <span style='color:{conf_color}'>{conf_label}</span> ({confidence:.0%}) |")
-    out.append(f"| Force | <span style='color:{force_color}'>{force}</span> |")
-    out.append(f"| Object | {obj} |")
-    out.append(f"| Canonical | \"{canonical}\" |")
-    out.append(f"| Input tokens | ~{input_tokens} |")
-    out.append(f"| Wire tokens | {wire_tokens} |")
-    out.append(f"| Reduction | {reduction:.0f}% |")
-    out.append("")
-
-    # Stage 1: Force classification
-    if force_detail_rows:
-        out.append(f"<details><summary><b>Stage 1: Force Classification</b> -- matched {len(force_detail_rows)} forces</summary>")
-        out.append("")
-        out.append(f"| Force | Matched Keywords | Score |")
-        out.append(f"|-------|-----------------|-------|")
-        for _, row in force_detail_rows[:6]:
-            out.append(row)
-        out.append("")
-        out.append(f"</details>")
-        out.append("")
-
-    # Stage 2: Object classification
-    if obj_detail_rows:
-        out.append(f"<details><summary><b>Stage 2: Object Classification</b> -- matched {len(obj_detail_rows)} objects</summary>")
-        out.append("")
-        out.append(f"| Object | Matched Keywords | Score |")
-        out.append(f"|--------|-----------------|-------|")
-        for _, row in obj_detail_rows[:6]:
-            out.append(row)
-        out.append("")
-        out.append(f"</details>")
-        out.append("")
-
-    if result.is_fallback:
-        out.append(f"*Fallback triggered: no keyword patterns matched with sufficient confidence. "
-                    f"Raw text stored out-of-band with ref pointer.*")
-
-    return "\n".join(out)
-
-
-# --------------------------------------------------------------------------
-# Encode tab logic
-# --------------------------------------------------------------------------
-
-def encode_message(src: str, dst: str, force: str, obj: str, payload: str) -> str:
-    if not src or not dst or not force or not obj:
-        return "Fill in source, destination, Force, and Object."
-
-    clean_src = "".join(c for c in src.strip() if c.isalnum())[:20] or "agent"
-    clean_dst = "".join(c for c in dst.strip() if c.isalnum())[:20] or "other"
-
-    parts = ["SLIP", "v3", clean_src, clean_dst, force, obj]
-    if payload.strip():
-        for token in payload.strip().split():
-            clean = "".join(c for c in token if c.isalnum())
-            if clean:
-                parts.append(clean[:30])
-
-    wire = " ".join(parts)
-    human = render_human(wire)
-
-    input_tokens = len(parts)
-    json_equiv = f'{{"from":"{src}","to":"{dst}","action":"{force}","target":"{obj}","payload":"{payload}"}}'
-    json_tokens = len(json_equiv.split()) + json_equiv.count('"') + json_equiv.count(':')
-    reduction = ((json_tokens - input_tokens) / json_tokens) * 100 if json_tokens > 0 else 0
-
-    return f"""```
-{wire}
-```
-
-> {human}
-
-| Metric | SLIP v3 | JSON equivalent |
-|--------|---------|-----------------|
-| Tokens | **{input_tokens}** | ~{json_tokens} |
-| Reduction | **{reduction:.0f}%** | -- |
-"""
-
-
-# --------------------------------------------------------------------------
-# Decode tab logic
-# --------------------------------------------------------------------------
-
-def decode_message(wire: str) -> str:
-    if not wire.strip():
-        return "Enter a SLIP v3 message to decode."
-
-    try:
-        msg = parse_slip(wire.strip())
-    except Exception as e:
-        return f"Parse error: {e}"
-
-    anchor = UCR.get_by_force_obj(msg.force, msg.obj)
-    canonical = anchor.canonical if anchor else "unknown"
-    coords = f"({', '.join(str(c) for c in anchor.coords)})" if anchor else "--"
-    force_desc = FORCE_DESCRIPTIONS.get(msg.force, "Unknown")
-    human = render_human(msg)
-
-    return f"""> {human}
-
-| Field | Value |
-|-------|-------|
-| Version | {msg.version} |
-| Source | `{msg.src}` |
-| Destination | `{msg.dst}` |
-| Force | **{msg.force}** -- {force_desc} |
-| Object | **{msg.obj}** |
-| Canonical | \"{canonical}\" |
-| Coords | `{coords}` |
-| Payload | {' '.join(msg.payload) if msg.payload else '--'} |
-| Fallback | {'`' + msg.fallback_ref + '`' if msg.fallback_ref else '--'} |
-"""
-
-
-# --------------------------------------------------------------------------
-# UCR Explorer
-# --------------------------------------------------------------------------
-
-def build_ucr_table(force_filter: str) -> str:
-    anchors = list(UCR.anchors.values())
-    anchors.sort(key=lambda a: a.index)
-
-    if force_filter and force_filter != "All":
-        anchors = [a for a in anchors if a.force == force_filter]
-
-    rows = []
-    for a in anchors:
-        color = FORCE_COLORS.get(a.force, "#666")
-        coords = ", ".join(str(c) for c in a.coords)
-        rows.append(
-            f"| `{a.index:#06x}` | <span style='color:{color}'>{a.force}</span> | "
-            f"{a.obj} | {a.canonical} | ({coords}) |"
-        )
-
-    header = f"**{len(anchors)} anchors** " + (f"(filtered: {force_filter})" if force_filter != "All" else "(all)")
-
-    return f"""{header}
-
-| Index | Force | Object | Canonical | Coords |
-|-------|-------|--------|-----------|--------|
-{chr(10).join(rows)}
-"""
-
-
-# --------------------------------------------------------------------------
-# Example sentences for the quantizer
-# --------------------------------------------------------------------------
-
-EXAMPLES = [
-    ["Please review the pull request for the auth module", "dev", "reviewer"],
-    ["The database migration is complete", "worker", "manager"],
-    ["I am blocked waiting for API credentials", "backend", "devops"],
-    ["I suggest we switch to Redis for the session store", "architect", "team"],
-    ["LGTM, approved for merge", "reviewer", "dev"],
-    ["Emergency: halt all production deployments now", "sre", "allAgents"],
-    ["What do you mean by 'optimize the query'?", "junior", "senior"],
-    ["I will handle the database migration this sprint", "dbAdmin", "pm"],
-    ["The API call to the payment provider timed out after 30s", "gateway", "monitor"],
-    ["Yes, but only if we add monitoring first", "lead", "architect"],
-    ["Ping, are you still there?", "coordinator", "worker"],
-    ["No, that approach will not scale to our traffic levels", "cto", "engineer"],
-]
-
-
-# --------------------------------------------------------------------------
-# Build Gradio app
-# --------------------------------------------------------------------------
-
-with gr.Blocks(
-    title="Slipstream v3",
-    theme=gr.themes.Soft(),
-    css="""
-    .hero-wire { font-size: 1.3em; font-family: monospace; }
-    footer { display: none !important; }
-    """
-) as demo:
-
-    gr.Markdown("""
-# Slipstream v3
-### Real-time semantic quantization for multi-agent AI coordination
-
-Type a natural language sentence and watch it get quantized into a
-factorized Force-Object wire message. No API keys, no GPU -- runs on
-the keyword classifier built into [slipcore](https://pypi.org/project/slipcore/).
-
----
-""")
-
-    with gr.Tabs():
-
-        # ---- Quantize tab (hero feature) ----
-        with gr.TabItem("Quantize", id="quantize"):
-            gr.Markdown("### Think -> Quantize -> Transmit")
-            gr.Markdown("Enter what you want to say. The quantizer maps it to Force + Object.")
-
-            with gr.Row():
-                q_text = gr.Textbox(
-                    label="Natural language input",
-                    placeholder="Please review the pull request for the auth module",
-                    lines=2,
-                    scale=4,
-                )
-            with gr.Row():
-                q_src = gr.Textbox(label="Source agent", value="alice", scale=1)
-                q_dst = gr.Textbox(label="Destination agent", value="bob", scale=1)
-                q_btn = gr.Button("Quantize", variant="primary", scale=1)
-
-            q_output = gr.Markdown()
-
-            q_btn.click(
-                quantize_sentence,
-                inputs=[q_text, q_src, q_dst],
-                outputs=q_output,
-            )
-            q_text.submit(
-                quantize_sentence,
-                inputs=[q_text, q_src, q_dst],
-                outputs=q_output,
-            )
-
-            gr.Markdown("#### Try these examples")
-            gr.Examples(
-                examples=EXAMPLES,
-                inputs=[q_text, q_src, q_dst],
-                outputs=q_output,
-                fn=quantize_sentence,
-                cache_examples=False,
-            )
-
-        # ---- Encode tab ----
-        with gr.TabItem("Encode", id="encode"):
-            gr.Markdown("### Manual encoder")
-            gr.Markdown("Build a wire message by picking Force and Object directly.")
-
-            with gr.Row():
-                enc_src = gr.Textbox(label="Source", value="alice", scale=1)
-                enc_dst = gr.Textbox(label="Destination", value="bob", scale=1)
-
-            with gr.Row():
-                enc_force = gr.Dropdown(
-                    choices=FORCES, label="Force", value="Request",
-                    info="Action verb", scale=1,
-                )
-                enc_obj = gr.Dropdown(
-                    choices=OBJECTS, label="Object", value="Review",
-                    info="Domain noun", scale=1,
-                )
-
-            enc_payload = gr.Textbox(label="Payload (optional)", placeholder="auth", value="auth")
-            enc_btn = gr.Button("Encode", variant="primary")
-            enc_output = gr.Markdown()
-
-            enc_btn.click(
-                encode_message,
-                inputs=[enc_src, enc_dst, enc_force, enc_obj, enc_payload],
-                outputs=enc_output,
-            )
-
-        # ---- Decode tab ----
-        with gr.TabItem("Decode", id="decode"):
-            gr.Markdown("### Wire format decoder")
-            gr.Markdown("Paste a SLIP v3 message to inspect it.")
-
-            dec_input = gr.Textbox(
-                label="SLIP v3 message",
-                value="SLIP v3 alice bob Request Review auth",
-                placeholder="SLIP v3 src dst Force Object payload...",
-            )
-            dec_btn = gr.Button("Decode", variant="primary")
-            dec_output = gr.Markdown()
-
-            dec_btn.click(decode_message, inputs=dec_input, outputs=dec_output)
-
-        # ---- UCR Explorer tab ----
-        with gr.TabItem("UCR Explorer", id="ucr"):
-            gr.Markdown("### Universal Concept Reference")
-            gr.Markdown("The 45 core anchors that form the shared semantic vocabulary.")
-
-            ucr_filter = gr.Dropdown(
-                choices=["All"] + FORCES,
-                value="All",
-                label="Filter by Force",
-            )
-            ucr_table = gr.Markdown(value=build_ucr_table("All"))
-
-            ucr_filter.change(build_ucr_table, inputs=ucr_filter, outputs=ucr_table)
-
-        # ---- About tab ----
-        with gr.TabItem("About", id="about"):
-            gr.Markdown(f"""
-### What is Slipstream?
-
-Slipstream is a protocol that performs **semantic quantization**: mapping free-form
-messages onto a shared Universal Concept Reference (UCR) and transmitting factorized
-intents (Force + Object) that identify structured actions.
-
-Instead of sending `"Could you please take a look at my pull request for the authentication module changes?"` (17 tokens),
-Slipstream transmits `SLIP v3 dev reviewer Request Review auth` (7 tokens).
-
-**82% token reduction** while preserving semantic fidelity.
-
-### How the quantizer works
-
-The keyword quantizer runs in two stages:
-
-1. **Force classification** -- match input against keyword patterns for each of the 12 Force tokens. Pick the highest-scoring Force.
-2. **Object classification** -- match input against keyword patterns for each of the 31+ Object tokens. Pick the highest-scoring Object.
-
-If no pattern matches above the confidence threshold, the message falls back to `Fallback Generic` with a pointer reference to the original text stored out-of-band.
-
-For production use, swap in the embedding-based `SemanticQuantizer` from `slipcore_ml` (requires sentence-transformers).
-
----
-
-### Resources
-
-| Resource | Link |
-|----------|------|
-| GitHub | [github.com/anthony-maio/slipcore](https://github.com/anthony-maio/slipcore) |
-| PyPI | `pip install slipcore` (v{__version__}) |
-| Paper | [doi.org/10.5281/zenodo.18063451](https://doi.org/10.5281/zenodo.18063451) |
-| SDK Guide | [docs/sdk-guide.md](https://github.com/anthony-maio/slipcore/blob/master/docs/sdk-guide.md) |
-| Model (LoRA) | [anthonym21/slipstream-glm-z1-9b](https://huggingface.co/anthonym21/slipstream-glm-z1-9b) |
-| Dataset | [anthonym21/slipstream-tqt](https://huggingface.co/datasets/anthonym21/slipstream-tqt) |
-
-### Cost savings at scale
-
-| Deployment | Agents | Annual JSON cost | Annual SLIP cost | Savings |
-|------------|--------|------------------|------------------|---------|
-| Startup | 10 | $3,600 | $650 | $2,950 |
-| Scale-up | 50 | $180,000 | $32,400 | $147,600 |
-| Enterprise | 1,000 | $2,500,000 | $450,000 | $2,050,000 |
-
----
-
-**Citation:**
-```bibtex
-@misc{{maio2025slipstream,
-  title={{Slipstream: Semantic Quantization for Efficient Multi-Agent Coordination}},
-  author={{Maio, Anthony}},
-  year={{2025}},
-  doi={{10.5281/zenodo.18063451}}
-}}
-```
-
-Apache 2.0 License | [Anthony Maio](https://github.com/anthony-maio)
-""")
-
-    gr.Markdown(f"<center><sub>slipcore v{__version__} | keyword quantizer | "
-                f"[source](https://github.com/anthony-maio/slipcore/tree/master/hf-space)</sub></center>")
-
-
-if __name__ == "__main__":
-    demo.launch()
+from __future__ import annotations
+
+from typing import Any
+
+import gradio as gr
+from app_logic import (
+    analyze_wire,
+    build_ucr_rows,
+    get_langgraph_snippet,
+    get_overview_metrics,
+    get_resource_rows,
+    get_training_guidance,
+    load_example_wires,
+)
+
+TABLE_HEADERS = ["index", "force", "object", "canonical", "coords", "core", "state"]
+SNIPPET_TOPICS = [
+    "Boundary Encode/Decode",
+    "Force:Object Router",
+    "Fallback-Aware Flow",
+]
+GUIDANCE_TOPICS = [
+    "When should I train?",
+    "What does the dataset look like?",
+    "What model artifacts exist?",
+    "How should I evaluate first?",
+]
+
+CUSTOM_CSS = """
+:root {
+  --slip-bg: #111111;
+  --slip-surface: #1a1a1a;
+  --slip-line: rgba(255, 255, 255, 0.08);
+  --slip-text: #f4efe6;
+  --slip-muted: #c5b8a0;
+  --slip-accent: #d18d3b;
+  --slip-cool: #83c5be;
+}
+
+body, .gradio-container {
+  background:
+    radial-gradient(circle at top left, rgba(209, 141, 59, 0.14), transparent 28%),
+    radial-gradient(circle at top right, rgba(131, 197, 190, 0.12), transparent 22%),
+    var(--slip-bg);
+  color: var(--slip-text);
+}
+
+.gradio-container {
+  max-width: 1320px !important;
+}
+
+.hero-shell {
+  border: 1px solid var(--slip-line);
+  border-radius: 28px;
+  padding: 28px;
+  background: linear-gradient(180deg, rgba(255,255,255,0.03), rgba(255,255,255,0.01));
+  box-shadow: 0 24px 80px rgba(0,0,0,0.24);
+}
+
+.hero-grid {
+  display: grid;
+  grid-template-columns: 1.2fr 0.8fr;
+  gap: 20px;
+}
+
+.eyebrow {
+  color: var(--slip-accent);
+  text-transform: uppercase;
+  letter-spacing: 0.12em;
+  font-size: 12px;
+  margin-bottom: 14px;
+}
+
+.hero-title {
+  font-size: 56px;
+  line-height: 0.95;
+  margin: 0 0 16px 0;
+  letter-spacing: -0.05em;
+}
+
+.hero-copy {
+  font-size: 17px;
+  line-height: 1.65;
+  color: var(--slip-muted);
+}
+
+.signal-card, .mini-card {
+  border: 1px solid var(--slip-line);
+  border-radius: 20px;
+  padding: 18px;
+  background: rgba(255,255,255,0.03);
+}
+
+.signal-label {
+  color: var(--slip-cool);
+  text-transform: uppercase;
+  letter-spacing: 0.10em;
+  font-size: 12px;
+  margin-bottom: 10px;
+}
+
+.signal-code {
+  background: rgba(255,255,255,0.04);
+  border: 1px solid rgba(255,255,255,0.08);
+  border-radius: 16px;
+  padding: 14px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 13px;
+  line-height: 1.65;
+  color: var(--slip-text);
+  white-space: pre-wrap;
+}
+
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 14px;
+  margin-top: 18px;
+}
+
+.stat-value {
+  font-size: 28px;
+  font-weight: 700;
+}
+
+.stat-label {
+  color: var(--slip-muted);
+  font-size: 13px;
+  margin-top: 6px;
+}
+
+.panel-copy {
+  color: var(--slip-muted);
+  line-height: 1.65;
+}
+
+@media (max-width: 960px) {
+  .hero-grid,
+  .stats-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .hero-title {
+    font-size: 42px;
+  }
+}
+"""
+
+
+def _metrics_html() -> str:
+    cards = []
+    for item in get_overview_metrics():
+        cards.append(
+            f"""
+            <div class="mini-card">
+              <div class="stat-value">{item["value"]}</div>
+              <div class="stat-label">{item["metric"]}</div>
+            </div>
+            """
+        )
+    return "<div class='stats-grid'>" + "".join(cards) + "</div>"
+
+
+def _resources_markdown() -> str:
+    rows = ["| Resource | Link |", "|---|---|"]
+    for item in get_resource_rows():
+        rows.append(f"| {item['resource']} | {item['link']} |")
+    return "\n".join(rows)
+
+
+def _render_ucr(force_filter: str, search: str) -> tuple[str, list[list[str]]]:
+    rows = build_ucr_rows(force_filter=force_filter, search=search)
+    summary = (
+        f"Showing **{len(rows)}** anchors"
+        if rows
+        else "No anchors matched the current filter."
+    )
+    data = [[row[header] for header in TABLE_HEADERS] for row in rows]
+    return summary, data
+
+
+def _render_analysis(wire: str) -> tuple[str, str, dict[str, Any], str]:
+    result = analyze_wire(wire)
+    if result["status"] == "valid":
+        status = "### Valid wire\nThis message passes Slipstream v3 validation."
+        issues = "No issues."
+    else:
+        status = "### Invalid wire\nThis message violates one or more Slipstream v3 invariants."
+        issues = "\n".join(f"- {issue}" for issue in result["issues"])
+    return status, issues, result["fields"], result["human"]
+
+
+def _load_example(example_type: str, selected: str | None) -> str:
+    if selected:
+        return selected
+    examples = load_example_wires(example_type)
+    return examples[0] if examples else ""
+
+
+def _example_choices(example_type: str) -> tuple[dict[str, Any], str]:
+    examples = load_example_wires(example_type)
+    value = examples[0] if examples else ""
+    return gr.update(choices=examples, value=value), value
+
+
+def _render_snippet(topic: str) -> tuple[str, str]:
+    copy = {
+        "Boundary Encode/Decode": (
+            "Add Slipstream at the handoff boundary. "
+            "Keep your graph state and existing node logic intact."
+        ),
+        "Force:Object Router": (
+            "Route on `Force:Object` once the message is decoded. "
+            "This is the smallest useful production pattern."
+        ),
+        "Fallback-Aware Flow": (
+            "Let fallback handle the long tail first. "
+            "Only train later if the fallback rate is too high for your workload."
+        ),
+    }[topic]
+    return copy, get_langgraph_snippet(topic)
+
+
+with gr.Blocks(title="Slipstream Lab") as demo:
+    gr.HTML(
+        """
+        <section class="hero-shell">
+          <div class="hero-grid">
+            <div>
+              <div class="eyebrow">Slipstream 3.1.1 · Hugging Face Technical Companion</div>
+              <h1 class="hero-title">Explore the protocol, not just the pitch.</h1>
+              <p class="hero-copy">
+                This Space is the technical counterpart to the static website.
+                It is designed for engineers evaluating Slipstream in real systems:
+                inspect UCR anchors, validate wire messages against the shipped invariants,
+                generate LangGraph integration snippets, and review the dataset/model path
+                without running live inference.
+              </p>
+              <p class="hero-copy">
+                It is CPU-first and ZeroGPU-compatible by design.
+                There is no mandatory GPU path and no large-model dependency in the app itself.
+              </p>
+            </div>
+            <div class="signal-card">
+              <div class="signal-label">Wire format</div>
+              <div class="signal-code">
+                SLIP v3 &lt;src&gt; &lt;dst&gt; &lt;Force&gt; &lt;Object&gt; [payload...]
+              </div>
+              <div class="signal-label" style="margin-top: 16px;">Example</div>
+              <div class="signal-code">SLIP v3 planner reviewer Request Review auth</div>
+              <div class="signal-label" style="margin-top: 16px;">Why it matters</div>
+              <div class="panel-copy">
+                Slipstream compresses routine coordination traffic into short, explicit
+                messages that are easier to route, validate, and reason about than
+                repeated JSON envelopes.
+              </div>
+            </div>
+          </div>
+        </section>
+        """
+    )
+
+    gr.HTML(_metrics_html())
+
+    with gr.Tabs():
+        with gr.TabItem("Overview"):
+            gr.Markdown(
+                """
+                ## What this Space is for
+
+                Use this Space when you want to inspect the released protocol,
+                validate concrete wire examples, or understand how Slipstream
+                fits into a LangGraph-style orchestration stack.
+
+                It does **not** try to be a second homepage and it does **not**
+                depend on live model inference.
+                """
+            )
+            gr.Markdown(_resources_markdown())
+
+        with gr.TabItem("UCR Explorer"):
+            gr.Markdown(
+                """
+                ## Universal Concept Reference
+
+                Browse the 45 core anchors that define the released
+                Slipstream 3.1.1 semantic surface. Filter by Force or search
+                across object names, canonical text, and coordinates.
+                """
+            )
+            with gr.Row():
+                force_filter = gr.Dropdown(
+                    choices=["All"] + sorted({row["force"] for row in build_ucr_rows()}),
+                    value="All",
+                    label="Force filter",
+                )
+                search_box = gr.Textbox(
+                    label="Search",
+                    placeholder="review, timeout, handoff, 3 4 0 4",
+                )
+            ucr_summary = gr.Markdown()
+            ucr_table = gr.Dataframe(
+                headers=TABLE_HEADERS,
+                datatype=["str"] * len(TABLE_HEADERS),
+                interactive=False,
+                wrap=True,
+            )
+            for event in (force_filter.change, search_box.submit):
+                event(
+                    _render_ucr,
+                    inputs=[force_filter, search_box],
+                    outputs=[ucr_summary, ucr_table],
+                )
+            demo.load(
+                _render_ucr,
+                inputs=[force_filter, search_box],
+                outputs=[ucr_summary, ucr_table],
+            )
+
+        with gr.TabItem("Conformance Lab"):
+            gr.Markdown(
+                """
+                ## Conformance Lab
+
+                Paste a `SLIP v3` wire message or load one of the shipped
+                conformance vectors. The validator below uses the library
+                implementation directly, so the results match the released
+                runtime behavior.
+                """
+            )
+            with gr.Row():
+                example_type = gr.Radio(
+                    choices=["Valid", "Invalid"],
+                    value="Valid",
+                    label="Example set",
+                )
+                example_wire = gr.Dropdown(
+                    choices=load_example_wires("Valid"),
+                    value=load_example_wires("Valid")[0],
+                    label="Conformance example",
+                )
+            wire_input = gr.Textbox(
+                label="Wire message",
+                lines=4,
+                value=load_example_wires("Valid")[0],
+            )
+            analyze_btn = gr.Button("Validate and parse", variant="primary")
+            status_md = gr.Markdown()
+            issues_md = gr.Markdown(label="Issues")
+            fields_json = gr.JSON(label="Parsed fields")
+            human_md = gr.Markdown(label="Human render")
+
+            example_type.change(
+                _example_choices,
+                inputs=example_type,
+                outputs=[example_wire, wire_input],
+            )
+            example_wire.change(
+                _load_example,
+                inputs=[example_type, example_wire],
+                outputs=wire_input,
+            )
+            analyze_btn.click(
+                _render_analysis,
+                inputs=wire_input,
+                outputs=[status_md, issues_md, fields_json, human_md],
+            )
+            demo.load(
+                _render_analysis,
+                inputs=wire_input,
+                outputs=[status_md, issues_md, fields_json, human_md],
+            )
+
+        with gr.TabItem("LangGraph Starter"):
+            gr.Markdown(
+                """
+                ## LangGraph Starter
+
+                These snippets are meant to be copied into your graph layer.
+                Start with boundary encode/decode and route on `Force:Object`.
+                Training is optional and should come only after you have
+                measured real traffic.
+                """
+            )
+            snippet_topic = gr.Dropdown(
+                choices=SNIPPET_TOPICS,
+                value=SNIPPET_TOPICS[0],
+                label="Pattern",
+            )
+            snippet_copy = gr.Markdown()
+            snippet_code = gr.Code(language="python", interactive=False)
+            snippet_topic.change(
+                _render_snippet,
+                inputs=snippet_topic,
+                outputs=[snippet_copy, snippet_code],
+            )
+            demo.load(
+                _render_snippet,
+                inputs=snippet_topic,
+                outputs=[snippet_copy, snippet_code],
+            )
+
+        with gr.TabItem("Dataset / Model"):
+            gr.Markdown(
+                """
+                ## Dataset and model path
+
+                Slipstream can be adopted without training. This tab is here to
+                clarify when training becomes useful, what the dataset contains,
+                and how to think about evaluation before you fine-tune anything.
+                """
+            )
+            guidance_topic = gr.Dropdown(
+                choices=GUIDANCE_TOPICS,
+                value=GUIDANCE_TOPICS[0],
+                label="Question",
+            )
+            guidance_md = gr.Markdown()
+            guidance_topic.change(get_training_guidance, inputs=guidance_topic, outputs=guidance_md)
+            demo.load(get_training_guidance, inputs=guidance_topic, outputs=guidance_md)
+
+
+if __name__ == "__main__":
+    demo.launch(
+        theme=gr.themes.Base(
+            primary_hue="amber",
+            secondary_hue="stone",
+            neutral_hue="zinc",
+        ),
+        css=CUSTOM_CSS,
+    )

app_logic.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from slipcore import (
+    LangGraphSlipstreamAdapter,
+    create_base_ucr,
+    parse_slip,
+    render_human,
+    validate_wire,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+VALID_VECTORS = ROOT / "spec" / "conformance" / "valid.jsonl"
+INVALID_VECTORS = ROOT / "spec" / "conformance" / "invalid.jsonl"
+
+
+@lru_cache(maxsize=1)
+def _base_ucr():
+    return create_base_ucr()
+
+
+@lru_cache(maxsize=1)
+def _adapter() -> LangGraphSlipstreamAdapter:
+    return LangGraphSlipstreamAdapter()
+
+
+def build_ucr_rows(force_filter: str = "All", search: str = "") -> list[dict[str, str]]:
+    query = search.strip().lower()
+    rows: list[dict[str, str]] = []
+
+    for anchor in sorted(_base_ucr(), key=lambda item: item.index):
+        if force_filter != "All" and anchor.force != force_filter:
+            continue
+
+        haystack = " ".join(
+            [
+                anchor.force,
+                anchor.obj,
+                anchor.canonical,
+                " ".join(str(value) for value in anchor.coords),
+            ]
+        ).lower()
+        if query and query not in haystack:
+            continue
+
+        rows.append(
+            {
+                "index": f"0x{anchor.index:04x}",
+                "force": anchor.force,
+                "object": anchor.obj,
+                "canonical": anchor.canonical,
+                "coords": str(anchor.coords),
+                "core": "yes" if anchor.is_core else "no",
+                "state": anchor.state.value,
+            }
+        )
+
+    return rows
+
+
+def analyze_wire(wire: str) -> dict[str, Any]:
+    wire = wire.strip()
+    issues = validate_wire(wire)
+    if issues:
+        return {
+            "status": "invalid",
+            "issues": issues,
+            "human": "",
+            "fields": {},
+        }
+
+    message = parse_slip(wire)
+    fields = {
+        "version": message.version,
+        "src": message.src,
+        "dst": message.dst,
+        "force": message.force,
+        "object": message.obj,
+        "payload": " ".join(message.payload),
+        "fallback_ref": message.fallback_ref or "",
+        "token_count": str(message.token_count_estimate),
+    }
+
+    return {
+        "status": "valid",
+        "issues": [],
+        "human": render_human(message),
+        "fields": fields,
+    }
+
+
+def load_example_wires(kind: str) -> list[str]:
+    path = VALID_VECTORS if kind == "Valid" else INVALID_VECTORS
+    examples: list[str] = []
+    with path.open(encoding="utf-8") as handle:
+        for line in handle:
+            record = json.loads(line)
+            examples.append(record["wire"])
+            if len(examples) == 8:
+                break
+    return examples
+
+
+LANGGRAPH_SNIPPETS = {
+    "Boundary Encode/Decode": """from typing import TypedDict
+from langgraph.graph import StateGraph
+
+from slipcore import (
+    LangGraphSlipstreamAdapter,
+    make_decode_node,
+    make_encode_node,
+)
+
+
+class AgentState(TypedDict, total=False):
+    thought: str
+    src: str
+    dst: str
+    slip_wire: str
+    slip_force: str
+    slip_obj: str
+
+
+adapter = LangGraphSlipstreamAdapter()
+encode_node = make_encode_node(adapter)
+decode_node = make_decode_node(adapter)
+
+builder = StateGraph(AgentState)
+builder.add_node("slip_encode", encode_node)
+builder.add_node("slip_decode", decode_node)
+""",
+    "Force:Object Router": """from slipcore import (
+    LangGraphSlipstreamAdapter,
+    make_force_object_router,
+)
+
+adapter = LangGraphSlipstreamAdapter()
+route = make_force_object_router(adapter)
+
+builder.add_conditional_edges(
+    "slip_decode",
+    route,
+    {
+        "Request:Review": "review_agent",
+        "Inform:Status": "status_agent",
+        "Fallback:Generic": "fallback_agent",
+    },
+)
+""",
+    "Fallback-Aware Flow": """from slipcore import LangGraphSlipstreamAdapter
+
+adapter = LangGraphSlipstreamAdapter()
+
+wire, result = adapter.encode_thought(
+    "Check kubernetes pod logs for OOMKilled events",
+    src="devops",
+    dst="sre",
+)
+
+decoded = adapter.decode_wire(wire)
+print(decoded.message.force, decoded.message.obj)
+print(decoded.fallback_text)
+""",
+}
+
+
+def get_langgraph_snippet(topic: str) -> str:
+    return LANGGRAPH_SNIPPETS[topic]
+
+
+TRAINING_GUIDANCE = {
+    "When should I train?": (
+        "Training is optional. Start with the built-in keyword quantizer, "
+        "strict wire validation, and pointer-based fallback. Measure "
+        "fallback rate and routing correctness first. Train only if your "
+        "workload needs higher intent recall than the rules-based path provides."
+    ),
+    "What does the dataset look like?": (
+        "The dataset is ShareGPT-style conversation data for Think -> "
+        "Quantize -> Transmit. Typical records include THOUGHT, QUANTIZE, "
+        "and SLIP lines so a model can learn the protocol without hiding "
+        "the reasoning step."
+    ),
+    "What model artifacts exist?": (
+        "Reference artifacts live on Hugging Face under the anthonym21 "
+        "namespace: the dataset `slipstream-tqt`, the LoRA adapter "
+        "`slipstream-glm-z1-9b`, and companion merged and GGUF variants."
+    ),
+    "How should I evaluate first?": (
+        "Build a small gold eval set from your own agent traffic. Track "
+        "Force accuracy, Object accuracy, fallback rate, and downstream "
+        "routing correctness before considering any fine-tuning pass."
+    ),
+}
+
+
+def get_training_guidance(topic: str) -> str:
+    return TRAINING_GUIDANCE[topic]
+
+
+def get_overview_metrics() -> list[dict[str, str]]:
+    return [
+        {"metric": "Current release", "value": "3.1.1"},
+        {"metric": "Core dependencies", "value": "0"},
+        {"metric": "Passing tests", "value": "583"},
+        {"metric": "Average token reduction", "value": "82%"},
+    ]
+
+
+def get_resource_rows() -> list[dict[str, str]]:
+    return [
+        {"resource": "Website", "link": "https://slipstream.making-minds.ai"},
+        {"resource": "GitHub", "link": "https://github.com/anthony-maio/slipcore"},
+        {"resource": "PyPI", "link": "https://pypi.org/project/slipcore/"},
+        {"resource": "Paper", "link": "https://doi.org/10.5281/zenodo.18063451"},
+        {
+            "resource": "Dataset",
+            "link": "https://huggingface.co/datasets/anthonym21/slipstream-tqt",
+        },
+        {
+            "resource": "Reference model",
+            "link": "https://huggingface.co/anthonym21/slipstream-glm-z1-9b",
+        },
+    ]

requirements.txt

@@ -1,2 +1 @@
-gradio>=5.0.0
-slipcore>=3.0.1
+slipcore>=3.1.1