hypernix 0.72.5.dev2__py3-none-any.whl → 0.72.5.dev3__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.dev2"
+__version__ = "0.72.5.dev3"
 DEFAULT_REPO_ID = "ray0rf1re/hyper-Nix.2"
 DEFAULT_MODEL = "qwen3.5-4b"  # New default model
 

hypernix/hyped_pro.js

@@ -423,7 +423,6 @@ 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" },
@@ -474,11 +473,6 @@ 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.
@@ -1153,139 +1147,6 @@ 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,87 +113,6 @@ _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
@@ -243,23 +162,10 @@ 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")
         
@@ -1164,16 +1070,10 @@ 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.
-    #
-    # 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.
+    # First arg isn't a subcommand -> print help instead of falling back to 'all'
     if raw[0] not in _SUBCOMMANDS:
-        return _unknown_command(raw[0])
+        _print_usage()
+        return 1
 
     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.9.2.3"
+BRIDGE_VERSION = "1.0.26.8.1.0"
 
 
 # ---------------------------------------------------------------------------
@@ -77,15 +77,7 @@ BRIDGE_VERSION = "1.0.26.9.2.3"
 # 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.
-# 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"})
+BACKGROUND_COMMANDS = frozenset({"chat", "download", "t1api_status"})
 
 # Backends whose generation loop polls should_stop. Anything else can be
 # asked to cancel, but the request will finish first.
@@ -236,69 +228,6 @@ 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,7 +166,6 @@ 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,
@@ -233,13 +232,9 @@ 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 ---------------------------------------------------
@@ -273,159 +268,6 @@ 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,20 +29,9 @@ 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 (
@@ -71,5 +60,4 @@ __all__ = [
     "Tool", "ToolContext", "ToolError", "ToolResult", "TOOLS", "run_tool", "tool_schemas",
     "syntax_verifier", "command_verifier", "combine",
     "SearchSpace", "Trial", "HPOResult", "random_search", "successive_halving",
-    "hyped",
 ]

hypernix/interfaces/noodle/tools.py

@@ -148,15 +148,6 @@ class ToolContext:
         """
         if not relative or not str(relative).strip():
             raise ToolError("A path is required", code="bad_path")
-        # expanduser() *after* the join, deliberately. By then any `~` the
-        # model supplied sits in the middle of the path, where it expands
-        # to nothing and stays a literal directory name under the root.
-        # Expanding first would turn `~/.ssh/id_rsa` into an absolute
-        # path to the real home directory -- and `Path(root) / "/abs"` is
-        # `/abs`, because pathlib's `/` discards the left side when the
-        # right is absolute. The containment check below still catches
-        # that, but it would be the only thing catching it. Do not
-        # "fix" this into expanding first.
         candidate = (self.root / str(relative)).expanduser()
         try:
             resolved = candidate.resolve()