hypernix 0.72.5.dev1__py3-none-any.whl → 0.72.5.dev2__py3-none-any.whl

hypernix/__init__.py

@@ -63,7 +63,7 @@ import importlib.util
 import sys
 from typing import TYPE_CHECKING, Any
 
-__version__ = "0.72.5.dev1"
+__version__ = "0.72.5.dev2"
 DEFAULT_REPO_ID = "ray0rf1re/hyper-Nix.2"
 DEFAULT_MODEL = "qwen3.5-4b"  # New default model
 

hypernix/hyped_pro.js

@@ -423,6 +423,7 @@ const COMMANDS = [
     { name: "/retry", desc: "Regenerate the last agent reply" },
     { name: "/key", desc: "Set/view a cloud API key: /key <vendor> [api-key]" },
     { name: "/t1api", desc: "HyperNix T1 API server: /t1api [status | url <url>]" },
+    { name: "/noodle", desc: "Run an autonomous agent swarm: /noodle <task>, or /noodle providers" },
     { name: "/version", desc: "Show the installed version and the latest public release" },
     { name: "/settings", desc: "View/change max input, output, and thinking tokens" },
     { name: "/tools", desc: "Toggle file create/edit/read/search tools on or off" },
@@ -473,6 +474,11 @@ let thinkingDisplay = THINKING_DISPLAY_MODES.includes(cfg.thinkingDisplay || "")
 // supports tool calling; hypernix.old_oven (the plain safetensors path)
 // has no tool-calling support to enable regardless of this setting.
 let toolsEnabled = cfg.toolsEnabled !== undefined ? cfg.toolsEnabled : true;
+// The Noodle swarm currently being polled, so `/noodle stop` with no
+// argument has something to aim at. Not persisted: a session id refers
+// to a thread inside the bridge process, and a stale one from last time
+// would address nothing.
+let noodleSession = null;
 const startTime = Date.now();
 // Models already confirmed present on disk this session, so we don't
 // re-check/re-download on every turn.
@@ -1147,6 +1153,139 @@ async function handleSlashCommand(cmdStr) {
             log(out.join(NL));
             break;
         }
+        // 0.72.6: Noodle. It has called itself "the autonomous executor
+        // inside Hyped Pro" since it shipped and was not reachable from here
+        // at all — running a swarm meant leaving this TUI and starting a
+        // different program in another terminal.
+        //
+        // A run is a session, not a call. `noodle_start` returns at once and
+        // this polls for events, so the swarm's progress lands in the
+        // scrollback live instead of the screen freezing for five minutes
+        // and then printing everything.
+        case "/noodle": {
+            const [sub, ...rest] = args;
+            if (sub === "providers" || sub === "models") {
+                const r = await bridge.call('noodle_providers', {});
+                if (!r.ok) {
+                    elog(r.code || 'HPT-NOODLE-001', r.error || 'could not list providers');
+                    break;
+                }
+                const out = [c256(96, "\n  Noodle providers:")];
+                (r.data.providers || []).forEach((p) => {
+                    const mark = p.ready ? c256(82, "✓") : dim("✗");
+                    const model = p.default_model ? dim(` ${p.default_model}`) : "";
+                    const why = p.reason ? dim(`  ${p.reason}`) : "";
+                    out.push(`  ${mark} ${c256(33, String(p.provider).padEnd(10))}${model}${why}`);
+                });
+                if ((r.data.adopted_keys || []).length) {
+                    out.push(dim(`\n  Using saved keys for: ${r.data.adopted_keys.join(", ")}`));
+                }
+                if (!r.data.any_ready) {
+                    out.push(c256(220, "\n  Nothing is usable yet. Set a key with /key <vendor> <key>,"));
+                    out.push(c256(220, "  or start Ollama for a local model."));
+                }
+                log(out.join(NL));
+                break;
+            }
+            if (sub === "sessions" || sub === "ls") {
+                const r = await bridge.call('noodle_sessions', {});
+                if (!r.ok) {
+                    elog(r.code || 'HPT-NOODLE-001', r.error || 'could not list sessions');
+                    break;
+                }
+                const list = r.data.sessions || [];
+                if (!list.length) {
+                    log(dim("  No Noodle sessions in this hyped-pro session yet."));
+                    break;
+                }
+                const out = [c256(96, "\n  Noodle sessions:")];
+                list.forEach((s) => {
+                    const state = s.running ? c256(220, "running") : (s.error ? c256(196, "failed") : c256(82, "done"));
+                    out.push(`  ${c256(33, s.session_id)} ${state} ${dim(`${s.elapsed}s`)}  ${String(s.prompt).slice(0, 48)}`);
+                });
+                log(out.join(NL));
+                break;
+            }
+            if (sub === "stop") {
+                const target = rest[0] || noodleSession;
+                if (!target) {
+                    log(dim("  Nothing to stop. /noodle sessions lists them."));
+                    break;
+                }
+                const r = await bridge.call('noodle_stop', { session: target });
+                if (!r.ok) {
+                    elog(r.code || 'HPT-NOODLE-001', r.error || 'could not stop it');
+                    break;
+                }
+                log(c256(220, `  Asked ${target} to stop.`));
+                // Said plainly because a "stop" that does not stop things is
+                // worth knowing about: every provider client is blocking HTTP in
+                // a thread pool, and a request already on the wire is paid for.
+                if (!r.data.swarm_notified) {
+                    log(dim("  Turns already in flight will finish — they are paid for either way."));
+                }
+                break;
+            }
+            const task = (sub ? [sub, ...rest] : []).join(" ").trim();
+            if (!task) {
+                log(c256(96, "\n  Usage:"));
+                log("  /noodle <task>            run an agent swarm on it");
+                log("  /noodle providers         which models it could use");
+                log("  /noodle sessions          past and running runs");
+                log("  /noodle stop [id]         ask a run to stop");
+                log(dim("\n  Agents get file tools rooted at ./.noodle — nothing outside it,"));
+                log(dim("  and no shell execution unless HYPED_NOODLE_EXEC=1 is set."));
+                break;
+            }
+            // Off by default and deliberately not a flag on the command. A
+            // chat TUI is a place people paste prompts without reading them
+            // closely, and "run whatever shell commands you like" should take
+            // more than a typo to switch on.
+            const allowExec = process.env.HYPED_NOODLE_EXEC === "1";
+            log(c256(96, `\n  Noodle: ${task}`));
+            if (allowExec)
+                log(c256(220, "  Shell execution is ON (HYPED_NOODLE_EXEC=1)."));
+            const started = await bridge.call('noodle_start', {
+                prompt: task,
+                allow_execute: allowExec,
+            });
+            if (!started.ok) {
+                elog(started.code || 'HPT-NOODLE-001', started.error || 'could not start the swarm');
+                log(dim("  /noodle providers shows what is usable here."));
+                break;
+            }
+            noodleSession = started.data.session_id;
+            log(dim(`  session ${noodleSession} · roster ${(started.data.roster || []).join(", ")} · root ${started.data.root}`));
+            // Long-poll until it finishes. The bridge answers a poll as soon
+            // as there is anything to say, so this is a live feed rather than
+            // a spin.
+            let running = true;
+            while (running) {
+                const tick = await bridge.call('noodle_poll', { session: noodleSession, timeout: 2.0 });
+                if (!tick.ok) {
+                    elog(tick.code || 'HPT-NOODLE-001', tick.error || 'poll failed');
+                    break;
+                }
+                (tick.data.events || []).forEach((ev) => {
+                    const kind = String(ev.kind || ev.type || "event");
+                    const detail = String(ev.message || ev.text || ev.tool || ev.task_id || "");
+                    log(`  ${dim(kind.padEnd(16))} ${detail.slice(0, 96)}`);
+                });
+                running = Boolean(tick.data.running);
+                if (!running) {
+                    if (tick.data.error) {
+                        log(c256(196, `  Swarm failed: ${tick.data.error}`));
+                    }
+                    else if (tick.data.report) {
+                        const rep = tick.data.report;
+                        const ok = rep.ok ? c256(82, "all tasks succeeded") : c256(220, `${(rep.failed || []).length} task(s) failed`);
+                        log(`  ${ok} ${dim(`in ${tick.data.elapsed}s`)}`);
+                    }
+                }
+            }
+            noodleSession = null;
+            break;
+        }
         case "/settings": {
             const SETTINGS_KEYS = ["max-input-tokens", "max-output-tokens", "max-thinking-tokens", "thinking-display"];
             if (!argText) {

hypernix/interfaces/cli.py

@@ -113,6 +113,87 @@ _SUBCOMMANDS = {
 }
 
 
+#: Spellings that are not subcommands but are obviously meant as one.
+#:
+#: Separate from difflib's fuzzy matching because these are not typos --
+#: they are the other correct spelling, or the name of the tool rather
+#: than the name of the subcommand. "quantise" is British English and
+#: this package's own docstrings use it throughout; "tvtoppro" is a
+#: console script people reasonably expect to work as a subcommand too.
+_COMMAND_ALIASES: dict[str, str] = {
+    "quantise": "quantize",
+    "quant": "quantize",
+    "q": "quantize",
+    "dl": "download",
+    "get": "download",
+    "pull": "download",
+    "conv": "convert",
+    "gguf": "convert",
+    "ls": "info",
+    "list": "info",
+    "version": "--version",
+    "help": "--help",
+    "tvtoppro": "tvtop",
+    "tvtop-pro": "tvtop",
+    "hyprslug": "quantize",
+    "doomslug": "quantize",
+    "keys": "gkey",
+    "key": "gkey",
+    "docs": "wiki",
+    "diagnose": "doctor",
+    "check": "doctor",
+    "dashboard": "cctvtop",
+    "monitor": "cctvtop",
+}
+
+
+def _suggest(typed: str, limit: int = 3) -> list[str]:
+    """Subcommands *typed* was probably meant to be.
+
+    Prefix matches first and exactly: somebody who typed ``down`` meant
+    ``download`` and difflib's ratio does not reliably rank a prefix
+    above a similarly-sized edit. Fuzzy matches fill the rest.
+    """
+    import difflib
+
+    lowered = typed.lower()
+    known = sorted(_SUBCOMMANDS)
+    prefix = [name for name in known if name.startswith(lowered)]
+    contains = [
+        name for name in known
+        if lowered in name and name not in prefix and len(lowered) >= 3
+    ]
+    fuzzy = [
+        name for name in difflib.get_close_matches(lowered, known, n=limit, cutoff=0.6)
+        if name not in prefix and name not in contains
+    ]
+    ordered: list[str] = []
+    for name in (*prefix, *contains, *fuzzy):
+        if name not in ordered:
+            ordered.append(name)
+    return ordered[:limit]
+
+
+def _unknown_command(typed: str) -> int:
+    """Say what was wrong with it, and what to type instead."""
+    print(f"hypernix: unknown command {typed!r}", file=sys.stderr)
+
+    alias = _COMMAND_ALIASES.get(typed.lower())
+    if alias:
+        print(f"\n  You want:  hypernix {alias}", file=sys.stderr)
+    else:
+        suggestions = _suggest(typed)
+        if len(suggestions) == 1:
+            print(f"\n  Did you mean:  hypernix {suggestions[0]}", file=sys.stderr)
+        elif suggestions:
+            print("\n  Did you mean one of these?", file=sys.stderr)
+            for name in suggestions:
+                print(f"      hypernix {name}", file=sys.stderr)
+
+    print("\n  hypernix --help   every subcommand", file=sys.stderr)
+    return 2
+
+
 def _print_usage() -> None:
     try:
         from rich.console import Console
@@ -162,10 +243,23 @@ def _print_usage() -> None:
         table.add_row("[green]config[/]", "Configuration management")
         table.add_row("[green]gkey[/]", "API key & access management (Gatekeeper + Keymaster)")
         table.add_row("[green]map[/]", "Steampunk schematic TUI: dials/pipes/steam for model + training state")
+        # These four dispatch and always have; they were simply never
+        # added to the menu, so `hypernix --help` was not a list of what
+        # hypernix can do and there was no way to find them at all.
+        table.add_row("[green]devices[/]", "list the GPUs/accelerators this machine has, and what they support")
+        table.add_row("[green]wakeup[/]", "wake-word detection: train a trigger phrase, then listen for it")
+        table.add_row("[green]websearch[/]", "web search backend used by the chat and assistant surfaces")
+        table.add_row("[green]hyprslug-headers[/]", "self-describing GGUF headers + the OpenAI-compatible sub-bit server")
         
         shortcuts = Text("Shortcuts:\n", style="bold yellow")
         shortcuts.append("  --auto-oven            download the default snapshot and run code completion\n", style="white")
         shortcuts.append("                         (equivalent to `hypernix oven --auto ...`).\n", style="dim")
+        shortcuts.append("\nAlso accepted: ", style="bold yellow")
+        shortcuts.append(
+            "tvtop (cctvtop) · fiz (fizzle) · camouflage (camo) · protect (prot) ·\n"
+            "                 fuse-box (fusebox)\n",
+            style="dim",
+        )
         
         help_text = Text("\nRun `hypernix <subcommand> --help` for per-command flags.\nRun `hypernix all --help` for the classic pipeline flags.", style="italic dim")
         
@@ -1070,10 +1164,16 @@ def main(argv: list[str] | None = None) -> int:
     if raw[0] == "--auto-oven":
         return _run_oven(["--auto", *raw[1:]])
 
-    # First arg isn't a subcommand -> print help instead of falling back to 'all'
+    # First arg isn't a subcommand.
+    #
+    # This used to print the whole forty-row menu and exit 1, without ever
+    # mentioning what was typed. `hypernix downlod` produced fifty lines
+    # of table, none of which said "downlod", so the failure looked
+    # exactly like asking for help on purpose. With this many subcommands
+    # -- and pairs like quantize/quantise and fizzle/fiz -- a suggestion
+    # is worth more than the whole menu.
     if raw[0] not in _SUBCOMMANDS:
-        _print_usage()
-        return 1
+        return _unknown_command(raw[0])
 
     cmd, rest = raw[0], raw[1:]
     if cmd == "all":

hypernix/interfaces/hyped_pro_bridge.py

@@ -43,7 +43,7 @@ from typing import Any
 
 from hypernix.interfaces import hyped_pro_core as core
 
-BRIDGE_VERSION = "1.0.26.8.1.0"
+BRIDGE_VERSION = "1.0.26.9.2.3"
 
 
 # ---------------------------------------------------------------------------
@@ -77,7 +77,15 @@ BRIDGE_VERSION = "1.0.26.8.1.0"
 # Commands that can take long enough to be worth cancelling, and are safe to
 # run off the main loop. Everything else is a fast config read/write and
 # stays inline, where it can't interleave with itself.
-BACKGROUND_COMMANDS = frozenset({"chat", "download", "t1api_status"})
+# noodle_poll is here because it long-polls: it waits up to `timeout`
+# seconds for an event rather than returning empty and being asked again
+# immediately. Inline, that wait would block the stdin loop and the TUI
+# could not deliver a cancel while a swarm was running -- the same bug
+# that made `chat` uncancellable before it moved off the loop.
+#
+# noodle_start is not here. It spawns a thread and returns at once, so
+# backgrounding it would buy a thread to start a thread.
+BACKGROUND_COMMANDS = frozenset({"chat", "download", "t1api_status", "noodle_poll"})
 
 # Backends whose generation loop polls should_stop. Anything else can be
 # asked to cancel, but the request will finish first.
@@ -228,6 +236,69 @@ def dispatch(req: dict[str, Any], cancel: threading.Event | None = None) -> dict
             core.set_t1_api_url(req["url"])
             return _ok(id_, {"url": core.t1_api_url()})
 
+        # -- 0.72.5: Noodle, the autonomous executor ------------------
+        #
+        # Noodle has described itself as "the autonomous executor inside
+        # Hyped Pro" since it shipped and was not reachable from
+        # hyped-pro at all. These five verbs are the connection.
+        #
+        # A run is a session rather than a call: it takes minutes and
+        # produces nothing until it ends, so doing it inside one request
+        # would hold a bridge thread and leave the TUI with nothing to
+        # draw. `noodle_start` returns a session id at once and
+        # `noodle_poll` drains events as they happen.
+        if cmd == "noodle_providers":
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            return _ok(id_, noodle.providers())
+
+        if cmd == "noodle_start":
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            try:
+                return _ok(id_, noodle.start(
+                    req.get("prompt", ""),
+                    roster=req.get("roster"),
+                    root=req.get("root"),
+                    tasks=req.get("tasks"),
+                    max_parallel=int(req.get("max_parallel", 4)),
+                    allow_execute=bool(req.get("allow_execute", False)),
+                    allow_outside=bool(req.get("allow_outside", False)),
+                    memory_enabled=bool(req.get("memory_enabled", False)),
+                    max_turns=int(req.get("max_turns", 12)),
+                    verify=req.get("verify", ""),
+                ))
+            except noodle.NoodleSessionError as exc:
+                return _err(id_, "HPB-NOODLE-001", str(exc))
+
+        if cmd == "noodle_poll":
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            try:
+                return _ok(id_, noodle.poll(
+                    req["session"], timeout=float(req.get("timeout", 0.0))
+                ))
+            except noodle.NoodleSessionError as exc:
+                return _err(id_, "HPB-NOODLE-002", str(exc))
+
+        if cmd == "noodle_stop":
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            try:
+                return _ok(id_, noodle.stop(req["session"]))
+            except noodle.NoodleSessionError as exc:
+                return _err(id_, "HPB-NOODLE-002", str(exc))
+
+        if cmd == "noodle_sessions":
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            if req.get("session"):
+                try:
+                    return _ok(id_, noodle.summary(req["session"]))
+                except noodle.NoodleSessionError as exc:
+                    return _err(id_, "HPB-NOODLE-002", str(exc))
+            return _ok(id_, {"sessions": noodle.sessions()})
+
         if cmd == "cancel":
             return _ok(id_, {"target": req.get("target"),
                              "result": _cancel(req.get("target"))})

hypernix/interfaces/hyped_pro_gui.py

@@ -166,6 +166,7 @@ def try_launch_qt() -> bool:
 def _make_main_window_class():
     from PySide6.QtCore import QObject, QThread, Signal
     from PySide6.QtWidgets import (
+        QCheckBox,
         QComboBox,
         QFormLayout,
         QHBoxLayout,
@@ -232,9 +233,13 @@ def _make_main_window_class():
             self._chat_thread: QThread | None = None
             self._dl_thread: QThread | None = None
 
+            self._noodle_session: str | None = None
+            self._noodle_timer = None
+
             tabs = QTabWidget()
             self.setCentralWidget(tabs)
             tabs.addTab(self._build_chat_tab(), "Chat")
+            tabs.addTab(self._build_noodle_tab(), "Noodle")
             tabs.addTab(self._build_keys_tab(), "API Keys")
 
         # -- Chat tab ---------------------------------------------------
@@ -268,6 +273,159 @@ def _make_main_window_class():
 
             return w
 
+        # -- Noodle tab -------------------------------------------------
+        #
+        # The same session API the TUI drives over the bridge, called
+        # directly because the GUI is already a Python process. A QTimer
+        # polls for events rather than a thread: poll() is a lock and a
+        # deque drain, far too cheap to be worth a thread, and doing it
+        # on the UI thread keeps every widget update where Qt wants it.
+        def _build_noodle_tab(self) -> QWidget:
+            w = QWidget()
+            layout = QVBoxLayout(w)
+
+            layout.addWidget(QLabel(
+                "Noodle runs agents against a task. They get file tools rooted "
+                "at ./.noodle and nothing outside it."
+            ))
+
+            top = QHBoxLayout()
+            self.noodle_task = QLineEdit()
+            self.noodle_task.setPlaceholderText("What should the swarm do?")
+            self.noodle_task.returnPressed.connect(self._on_noodle_start)
+            self.noodle_start_btn = QPushButton("Run")
+            self.noodle_start_btn.clicked.connect(self._on_noodle_start)
+            self.noodle_stop_btn = QPushButton("Stop")
+            self.noodle_stop_btn.setEnabled(False)
+            self.noodle_stop_btn.clicked.connect(self._on_noodle_stop)
+            top.addWidget(self.noodle_task, stretch=1)
+            top.addWidget(self.noodle_start_btn)
+            top.addWidget(self.noodle_stop_btn)
+            layout.addLayout(top)
+
+            self.noodle_exec = QCheckBox(
+                "Allow shell execution (agents may run commands)"
+            )
+            layout.addWidget(self.noodle_exec)
+
+            self.noodle_log = QTextEdit()
+            self.noodle_log.setReadOnly(True)
+            layout.addWidget(self.noodle_log, stretch=1)
+
+            self.noodle_status = QLabel("")
+            layout.addWidget(self.noodle_status)
+
+            self._refresh_noodle_providers()
+            return w
+
+        def _refresh_noodle_providers(self) -> None:
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            try:
+                info = noodle.providers()
+            except Exception as exc:  # noqa: BLE001 - a tab must still build
+                self.noodle_status.setText(f"Could not list providers: {exc}")
+                return
+            if info["any_ready"]:
+                self.noodle_status.setText(
+                    "Ready: " + ", ".join(info["ready"])
+                )
+            else:
+                self.noodle_status.setText(
+                    "No provider is usable yet — set a key in the API Keys tab, "
+                    "or start Ollama."
+                )
+
+        def _noodle_append(self, text: str) -> None:
+            self.noodle_log.append(text)
+
+        def _on_noodle_start(self) -> None:
+            from PySide6.QtCore import QTimer
+
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            task = self.noodle_task.text().strip()
+            if not task:
+                return
+            self.noodle_log.clear()
+            try:
+                session = noodle.start(
+                    task, allow_execute=self.noodle_exec.isChecked()
+                )
+            except noodle.NoodleSessionError as exc:
+                self._noodle_append(
+                    f'<span style="color:#e05555">{exc}</span>'
+                )
+                return
+            self._noodle_session = session["session_id"]
+            self.noodle_start_btn.setEnabled(False)
+            self.noodle_stop_btn.setEnabled(True)
+            self.noodle_task.setEnabled(False)
+            self._noodle_append(
+                f'<i>session {session["session_id"]} · '
+                f'{", ".join(session["roster"])} · {session["root"]}</i>'
+            )
+            self._noodle_timer = QTimer(self)
+            self._noodle_timer.timeout.connect(self._on_noodle_tick)
+            self._noodle_timer.start(400)
+
+        def _on_noodle_tick(self) -> None:
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            if not self._noodle_session:
+                return
+            try:
+                tick = noodle.poll(self._noodle_session)
+            except noodle.NoodleSessionError as exc:
+                self._noodle_append(f'<span style="color:#e05555">{exc}</span>')
+                self._noodle_finish()
+                return
+            for event in tick["events"]:
+                kind = str(event.get("kind") or event.get("type") or "event")
+                detail = str(
+                    event.get("message") or event.get("text")
+                    or event.get("tool") or event.get("task_id") or ""
+                )
+                self._noodle_append(f"<b>{kind}</b> {detail}")
+            if not tick["running"]:
+                if tick["error"]:
+                    self._noodle_append(
+                        f'<span style="color:#e05555">{tick["error"]}</span>'
+                    )
+                elif tick["report"]:
+                    ok = tick["report"].get("ok")
+                    self._noodle_append(
+                        f'<b>{"Done" if ok else "Finished with failures"}</b> '
+                        f'in {tick["elapsed"]}s'
+                    )
+                self._noodle_finish()
+
+        def _on_noodle_stop(self) -> None:
+            from hypernix.interfaces.noodle import hyped as noodle
+
+            if not self._noodle_session:
+                return
+            try:
+                result = noodle.stop(self._noodle_session)
+            except noodle.NoodleSessionError as exc:
+                self._noodle_append(f'<span style="color:#e05555">{exc}</span>')
+                return
+            self._noodle_append("<i>Stopping…</i>")
+            if not result["swarm_notified"]:
+                self._noodle_append(
+                    "<i>Turns already in flight will finish — they are paid "
+                    "for either way.</i>"
+                )
+
+        def _noodle_finish(self) -> None:
+            if self._noodle_timer is not None:
+                self._noodle_timer.stop()
+                self._noodle_timer = None
+            self._noodle_session = None
+            self.noodle_start_btn.setEnabled(True)
+            self.noodle_stop_btn.setEnabled(False)
+            self.noodle_task.setEnabled(True)
+
         def _current_model_short(self) -> str:
             return self.model_box.currentData()
 

hypernix/interfaces/noodle/__init__.py

@@ -29,9 +29,20 @@ to a different provider on its own (surprising invoices in one direction,
 surprising output in the other), and it does not execute a client
 application a remote server asked it to run. Both are opt-in and both
 say what they are doing.
+
+Inside hyped-pro
+----------------
+The line above about being "the autonomous executor inside Hyped Pro" was
+aspirational until 0.72.5: Noodle was a library and a console script, and
+hyped-pro had no command, no bridge verb and no idea it existed.
+:mod:`hypernix.interfaces.noodle.hyped` is the connection — sessions the
+TUI and the GUI drive with ``/noodle`` and a Noodle tab respectively,
+with a live event feed rather than a frozen screen for the length of a
+run.
 """
 from __future__ import annotations
 
+from . import hyped
 from .agent import Agent, AgentEvent, AgentResult
 from .hpo import HPOResult, SearchSpace, Trial, random_search, successive_halving
 from .providers import (
@@ -60,4 +71,5 @@ __all__ = [
     "Tool", "ToolContext", "ToolError", "ToolResult", "TOOLS", "run_tool", "tool_schemas",
     "syntax_verifier", "command_verifier", "combine",
     "SearchSpace", "Trial", "HPOResult", "random_search", "successive_halving",
+    "hyped",
 ]