tina4-python 3.13.131__tar.gz → 3.13.133__tar.gz

{tina4_python-3.13.131 → tina4_python-3.13.133}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tina4-python
-Version: 3.13.131
+Version: 3.13.133
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.131 → tina4_python-3.13.133}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.131"
+version = "3.13.133"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/__init__.py

@@ -51,7 +51,7 @@ def _resolve_version() -> str:
     #
     # test_version_constant.py now asserts this literal equals the pyproject
     # version, so the release bump cannot leave it behind again.
-    return "3.13.131"
+    return "3.13.133"
 
 
 __version__ = _resolve_version()

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/cli/__init__.py

@@ -1795,15 +1795,10 @@ async def list_{route_path}(request, response):
     page = int(request.query.get("page", 1))
     per_page = int(request.query.get("per_page", 20))
     offset = (page - 1) * per_page
-    records, total = {model}.where("1=1", limit=per_page, offset=offset, with_count=True)
+    records = {model}.where("1=1", limit=per_page, offset=offset)
     # tina4:edit  customise the list projection (filters, ordering, fields)
-    return response({{
-        "records": [r.to_dict() for r in records],
-        "count": total,
-        "page": page,
-        "per_page": per_page,
-        "total_pages": max(1, -(-total // per_page)),
-    }})
+    # records.to_paginate() -> records, total, page, per_page, total_pages, limit, offset
+    return response(records.to_paginate())
 
 
 @description("Get a {singular} by ID")
@@ -1862,7 +1857,7 @@ async def delete_{singular}(request, response):
         b_list = _ai_fill(
             f"list_{route_path}",
             f"return the {route_path} collection (add pagination if it grows)",
-            f"{m}.all()  or  {m}.where(sql, params, with_count=True)  (import {m} from src.orm.{m})",
+            f"{m}.all()  or  {m}.where(sql, params).to_paginate()  (import {m} from src.orm.{m})",
             f"list_{route_path}: query and return the records",
             ret='response({"records": [r.to_dict() for r in rows]})',
             ground=f'tina4_context("list ORM records with pagination", "python")',

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/core/server.py

@@ -3462,6 +3462,64 @@ def resolve_config(cli_host: str | None = None, cli_port: int | None = None) ->
     return host, port
 
 
+def loopback_bind_hosts(host: str) -> list[str]:
+    """Sibling loopback addresses to ALSO listen on, so ``localhost`` reaches
+    the dev server whether the OS resolves it to IPv4 (127.0.0.1) or IPv6 (::1).
+
+    Windows resolves ``localhost`` to ``::1`` FIRST, so a server bound only to
+    127.0.0.1 — or 0.0.0.0, the IPv4 wildcard, which does NOT cover IPv6 —
+    refused the browser with ERR_CONNECTION_REFUSED even though it was serving.
+    Binding both loopback families closes that gap.
+
+    Returns only the families a direct bind of ``host`` does not already cover.
+    A host that is neither loopback nor a wildcard yields an empty list — an
+    explicit LAN address is left exactly as asked. The host is normalised
+    (whitespace and IPv6 brackets stripped, lower-cased) so ``" [::1] "`` maps
+    the same as ``"::1"``. Addresses are returned WITHOUT brackets: Python's
+    asyncio/socket layer takes a bare ``"::1"``.
+
+    Mirrors PHP ``Server::loopbackBindHosts`` (which returns bracketed forms
+    because PHP's stream_socket_server needs them).
+
+    Args:
+        host: The host the main socket binds.
+
+    Returns:
+        Extra bind addresses (possibly empty).
+    """
+    normalized = host.strip().strip("[]").lower()
+
+    return {
+        "localhost": ["127.0.0.1", "::1"],
+        "127.0.0.1": ["::1"],
+        "0.0.0.0": ["::1"],
+        "::1": ["127.0.0.1"],
+        "::": ["127.0.0.1"],
+    }.get(normalized, [])
+
+
+async def _bind_loopback_siblings(handler, host: str, port: int) -> list:
+    """Best-effort listeners on the sibling loopback family (see
+    :func:`loopback_bind_hosts`), serving the SAME ``handler`` as the primary.
+
+    Each sibling bind is wrapped: a family the primary socket already answers
+    (EADDRINUSE), or one this host cannot provide (EADDRNOTAVAIL / EAFNOSUPPORT),
+    raises ``OSError`` and is skipped. A sibling failure NEVER fails startup —
+    the primary bind owns that. Returns the asyncio servers that bound (possibly
+    empty); the caller closes them alongside the primary.
+    """
+    servers = []
+    for sibling_host in loopback_bind_hosts(host):
+        try:
+            servers.append(await asyncio.start_server(handler, sibling_host, port))
+        except OSError as sibling_error:
+            Log.debug(
+                f"Loopback sibling {sibling_host}:{port} not bound "
+                f"({type(sibling_error).__name__}: {sibling_error}) — skipping"
+            )
+    return servers
+
+
 _PORT_DEPRECATION_WARNED = False
 
 
@@ -4011,6 +4069,15 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
 
         server = await start_server(_handle_connection, host, port)
 
+        # ALSO listen on the sibling loopback family, best-effort, on the same
+        # main port. `localhost` resolves to ::1 (IPv6) first on Windows, so a
+        # server bound only to 127.0.0.1 (or the IPv4 wildcard 0.0.0.0) refused
+        # the browser with ERR_CONNECTION_REFUSED. Each sibling bind is caught
+        # and skipped on OSError — a family already answered by the primary, or
+        # unavailable here, never fails startup. The primary bind above is
+        # unchanged and owns the fail-closed behaviour.
+        loopback_servers = await _bind_loopback_siblings(_handle_connection, host, port)
+
         # Test port (port + 1000) — stable, no live-reload WebSocket
         ai_server = None
         if _ai_port:
@@ -4041,7 +4108,9 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
 
         # 1. Stop accepting FIRST. A connection that arrives after the signal
         #    must get a clean CONNECTION REFUSED — not a 503, not a TCP reset.
-        live_servers = [s for s in (ai_server, server) if s is not None]
+        live_servers = [
+            s for s in (ai_server, server, *loopback_servers) if s is not None
+        ]
         for live_server in live_servers:
             live_server.close()
 

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/database/adapter.py

@@ -1172,6 +1172,30 @@ class SqlCrudMixin:
             sql += f" WHERE {self._marked_filter(filter_sql)}"
         return self.execute(sql, params or [])
 
+    def _returning_pk(self, table: str) -> str | None:
+        """The table's single PRIMARY KEY column, for RETURNING emulation.
+
+        MySQL, MSSQL and Firebird have no usable native RETURNING here (Firebird
+        has it from 2.1+ but this adapter emulates for cross-engine consistency),
+        so after an INSERT they re-select the just-inserted row by its REAL
+        primary key -- never a hardcoded ``id`` (the ``*-RETURNING-ID`` fixes: a
+        table whose PK is not named ``id`` used to fail or re-select the wrong
+        row). Introspected via :meth:`get_columns` and cached per table. Returns
+        ``None`` when the table has no single-column PK, so a composite or
+        key-less table degrades to no re-select rather than a wrong one.
+
+        Shared by every SQL adapter that emulates RETURNING; engines with native
+        RETURNING (PostgreSQL, SQLite) never call it.
+        """
+        cache = self.__dict__.setdefault("_returning_pk_cache", {})
+        if table not in cache:
+            try:
+                pks = [c["name"] for c in self.get_columns(table) if c.get("primary_key")]
+            except Exception:  # noqa: BLE001 - no introspection => no re-select
+                pks = []
+            cache[table] = pks[0] if len(pks) == 1 else None
+        return cache[table]
+
 
 # ── SQL Translation Rules ──────────────────────────────────────
 # Reusable translation functions for common cross-engine quirks.

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/database/firebird.py

@@ -280,6 +280,31 @@ class FirebirdAdapter(SqlCrudMixin, DatabaseAdapter):
             self._conn.close()
             self._conn = None
 
+    def __del__(self):
+        # Deterministic teardown when a caller (or a test) drops this adapter
+        # without calling close(). Without it, firebird-driver's OWN Connection
+        # finalizer later runs a rollback on a transaction whose handle is no
+        # longer valid -- "invalid transaction handle (expecting explicit
+        # transaction start)" -- which surfaces as a
+        # PytestUnraisableExceptionWarning (and GC noise in an app). Resolve any
+        # open transaction and detach HERE, so the driver's finalizer finds an
+        # already-closed connection and has nothing left to roll back
+        # (FB-DEL-CLOSE). __del__ can run during interpreter shutdown and on an
+        # already-dead connection, so swallow everything.
+        conn = getattr(self, "_conn", None)
+        if conn is None:
+            return
+        try:
+            if self._active_transaction() is not None:
+                conn.rollback()
+        except Exception:  # noqa: BLE001 - stale/dead handle; nothing to undo
+            pass
+        try:
+            conn.close()
+        except Exception:  # noqa: BLE001 - best-effort detach during GC
+            pass
+        self._conn = None
+
     def execute(self, sql: str, params: list = None) -> DatabaseResult:
         sql = self._translate_sql(sql)
 
@@ -297,7 +322,19 @@ class FirebirdAdapter(SqlCrudMixin, DatabaseAdapter):
         # reflects the LAST statement executed on the cursor, so the generator
         # re-select below (another execute on this same cursor) would otherwise
         # clobber the INSERT/UPDATE/DELETE count (FB-AFFECTED-FAB).
-        affected = cursor.rowcount if cursor.rowcount >= 0 else 0
+        #
+        # A DDL statement (CREATE/DROP/ALTER TABLE, etc.) has NO row count:
+        # firebird-driver's `rowcount` probes `get_info(RECORDS)` on the cursor,
+        # which the server answers with an error response for DDL, and the driver
+        # raises `InterfaceError: Result code does not match request code`. Reading
+        # rowcount unconditionally therefore blew up every DDL execute (create_table,
+        # migrations, the live-Firebird test fixtures) -- FB-DDL-ROWCOUNT. Guard it:
+        # DDL (and any statement without a countable result) yields 0 affected rows.
+        try:
+            _row_count = cursor.rowcount
+            affected = _row_count if _row_count >= 0 else 0
+        except Exception:  # noqa: BLE001 - no rowcount on DDL; it is not a write
+            affected = 0
 
         records = []
         last_id = None
@@ -611,28 +648,6 @@ class FirebirdAdapter(SqlCrudMixin, DatabaseAdapter):
             return token[1:-1].replace('""', '"')
         return token
 
-    def _returning_pk(self, table: str) -> str | None:
-        """The table's single PRIMARY KEY column, for the RETURNING re-select.
-
-        Firebird 2.1+ has native RETURNING but this adapter emulates it for
-        consistency, so an INSERT ... RETURNING re-selects the just-inserted row
-        -- by its REAL primary key, never a hardcoded ``id`` (FB-RETURNING-ID).
-        A table whose PK is not named ``id`` used to raise a Firebird 'Dynamic
-        SQL Error' from ``WHERE id = ?``. Introspected via :meth:`get_columns`
-        and cached per table. Returns ``None`` for a composite or key-less table
-        (which degrades to the generator last-id with no re-select rather than a
-        wrong one). The same defect+fix feature 10 applied to mysql.py and
-        feature 11 to mssql.py.
-        """
-        cache = self.__dict__.setdefault("_returning_pk_cache", {})
-        if table not in cache:
-            try:
-                pks = [c["name"] for c in self.get_columns(table) if c.get("primary_key")]
-            except Exception:  # noqa: BLE001 - no introspection => no re-select
-                pks = []
-            cache[table] = pks[0] if len(pks) == 1 else None
-        return cache[table]
-
     # -- SQL Translation -----------------------------------------------
 
     def _translate_sql(self, sql: str) -> str:

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/database/mssql.py

@@ -319,23 +319,6 @@ class MSSQLAdapter(SqlCrudMixin, DatabaseAdapter):
 
         return q(table) if schema is None else f"{q(schema)}.{q(table)}"
 
-    def _returning_pk(self, table: str) -> str | None:
-        """The table's single PRIMARY KEY column, for RETURNING emulation.
-
-        SQL Server has no RETURNING, so the provider re-selects the inserted row
-        by its REAL primary key - never a hardcoded ``id`` (MSSQL-RETURNING-ID).
-        Introspected via :meth:`get_columns` and cached per table. Returns
-        ``None`` when the table has no single-column PK (a composite or key-less
-        table degrades to no re-select rather than a wrong one)."""
-        cache = self.__dict__.setdefault("_returning_pk_cache", {})
-        if table not in cache:
-            try:
-                pks = [c["name"] for c in self.get_columns(table) if c.get("primary_key")]
-            except Exception:
-                pks = []
-            cache[table] = pks[0] if len(pks) == 1 else None
-        return cache[table]
-
     # -- SQL Translation -----------------------------------------------
 
     def _translate_sql(self, sql: str) -> str:

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/database/mysql.py

@@ -289,23 +289,6 @@ class MySQLAdapter(SqlCrudMixin, DatabaseAdapter):
 
         return q(table) if schema is None else f"{q(schema)}.{q(table)}"
 
-    def _returning_pk(self, table: str) -> str | None:
-        """The table's single PRIMARY KEY column, for RETURNING emulation.
-
-        MySQL has no RETURNING, so the provider re-selects the inserted row by
-        its REAL primary key - never a hardcoded ``id`` (MYSQL-RETURNING-ID).
-        Introspected via :meth:`get_columns` and cached per table. Returns
-        ``None`` when the table has no single-column PK (a composite or key-less
-        table degrades to no re-select rather than a wrong one)."""
-        cache = self.__dict__.setdefault("_returning_pk_cache", {})
-        if table not in cache:
-            try:
-                pks = [c["name"] for c in self.get_columns(table) if c.get("primary_key")]
-            except Exception:
-                pks = []
-            cache[table] = pks[0] if len(pks) == 1 else None
-        return cache[table]
-
     def get_database_type(self) -> str:
         return "mysql"
 

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/dev_admin/__init__.py

@@ -499,13 +499,6 @@ def get_api_handlers() -> dict:
         "/__dev/api/websockets": ("GET", _api_websockets),
         "/__dev/api/websockets/disconnect": ("POST", _api_ws_disconnect),
         "/__dev/api/system": ("GET", _api_system),
-        "/__dev/api/chat": ("POST", _api_chat),
-        # Thread CRUD — exact match handles GET (list) + POST (create);
-        # the "/*" key is the prefix-fallback for /threads/{id}[/messages]
-        # which the dev_admin dispatcher routes to _api_threads_sub.
-        # "*" method = handler switches on request.method itself.
-        "/__dev/api/threads":   ("*", _api_threads),
-        "/__dev/api/threads/*": ("*", _api_threads_sub),
         # ── Customer feedback widget (Tier 1: intake-only) ──
         # /__feedback/widget.js — bundle served at top-level so HTML
         # pages can embed without a /__dev path (the widget is for
@@ -529,18 +522,6 @@ def get_api_handlers() -> dict:
         "/embed":  ("GET", _api_service_embed),
         "/image":  ("GET", _api_service_image),
         "/rag":    ("GET", _api_service_rag),
-        # Thoughts — proxied to the rust agent server when it's running.
-        "/__dev/api/thoughts": ("GET", _api_thoughts),
-        # Supervisor orchestration — transparent proxy to the rust
-        # agent server (port = framework port + 2000). When tina4
-        # serve isn't running these respond 503 with a helpful hint
-        # instead of failing silently.
-        "/__dev/api/supervise/create":   ("POST", _api_supervise_create),
-        "/__dev/api/supervise/sessions": ("GET",  _api_supervise_sessions),
-        "/__dev/api/supervise/diff":     ("GET",  _api_supervise_diff),
-        "/__dev/api/supervise/commit":   ("POST", _api_supervise_commit),
-        "/__dev/api/supervise/cancel":   ("POST", _api_supervise_cancel),
-        "/__dev/api/execute":            ("POST", _api_execute),
         "/__dev/api/tool": ("POST", _api_tool),
         "/__dev/api/connections": ("GET", _api_connections),
         "/__dev/api/connections/test": ("POST", _api_connections_test),
@@ -1315,15 +1296,15 @@ async def _api_service_rag(request, response):
 def _supervisor_base_url() -> str:
     """Return the URL of the co-located rust agent server, if any.
 
-    Resolution order (first match wins):
+    Still used by the customer-feedback widget (``/__feedback/api/turn``),
+    which forwards to the agent's ``/feedback/intake``. Resolution order
+    (first match wins):
 
       1. `TINA4_SUPERVISOR_URL` — full URL for non-localhost deployments.
       2. `TINA4_AGENT_PORT` — explicit port override.
       3. `PORT + 2000` — auto-derived. `tina4 serve` exports the
          framework's PORT into the child process AND spawns the agent
-         on `port + 2000` (main.rs::handle_serve). Reading PORT here
-         keeps both sides aligned automatically: Python on 7146 →
-         agent on 9146, Node on 7148 → agent on 9148, etc.
+         on `port + 2000` (main.rs::handle_serve).
       4. Hardcoded 9145 — matches `tina4 agent` standalone's default
          (main.rs::handle_agent), for users running the agent without
          going through `tina4 serve`.
@@ -1343,174 +1324,6 @@ def _supervisor_base_url() -> str:
     return "http://127.0.0.1:9145"
 
 
-async def _proxy_to_supervisor(request, response, downstream_path: str):
-    """Forward a dev-admin request to the rust agent server.
-
-    The SPA's supervisor UI calls paths like ``/__dev/api/supervise/create``;
-    we strip the ``/__dev/api`` prefix and POST/GET the same body+query to
-    the agent server. Returns the agent's response verbatim. When the
-    agent isn't reachable (tina4 serve not running, or bare framework)
-    we respond with a specific 503 so the SPA can show a useful error
-    instead of silently doing nothing.
-    """
-    import urllib.request
-    import urllib.error
-
-    base = _supervisor_base_url()
-    qs = ""
-    try:
-        if hasattr(request, "query") and request.query:
-            from urllib.parse import urlencode
-            qs = "?" + urlencode(request.query)
-    except Exception:
-        qs = ""
-    target = f"{base}{downstream_path}{qs}"
-
-    method = (getattr(request, "method", "GET") or "GET").upper()
-    data = None
-    if method in ("POST", "PUT", "PATCH", "DELETE"):
-        body = getattr(request, "body", None)
-        if isinstance(body, dict):
-            # SPA→agent convention fixup: `/execute` sends plan_file as
-            # a bare filename but the rust agent expects a project-relative
-            # path. Prepend `plan/` when no slash is present.
-            pf = body.get("plan_file")
-            if isinstance(pf, str) and pf and "/" not in pf:
-                body = dict(body)
-                body["plan_file"] = f"plan/{pf}"
-            data = json.dumps(body).encode()
-        elif isinstance(body, list):
-            data = json.dumps(body).encode()
-        elif isinstance(body, str) and body:
-            data = body.encode()
-
-    import asyncio
-
-    req = urllib.request.Request(
-        target,
-        data=data,
-        method=method,
-        headers={"Content-Type": "application/json"},
-    )
-    # /execute and /chat run the multi-agent loop — supervisor +
-    # planner + coder, each a multi-second LLM call. Other
-    # supervise/* calls are metadata-only and return fast, so a
-    # generous shared timeout for the heavy ones is cheaper than
-    # branching on every endpoint.
-    timeout = 600 if downstream_path in ("/execute", "/chat") else 30
-
-    # Open the upstream connection in a thread — urlopen is blocking.
-    # We DON'T read the body here; that's done below either in one shot
-    # (JSON path) or chunk-by-chunk (SSE path) so progress events reach
-    # the SPA live instead of after the whole 30-second supervisor run.
-    try:
-        upstream = await asyncio.to_thread(
-            urllib.request.urlopen, req, None, timeout
-        )
-    except urllib.error.HTTPError as e:
-        err_body = e.read().decode() if e.fp else str(e)
-        try:
-            return response(json.loads(err_body), e.code)
-        except Exception:
-            return response({"error": err_body[:300]}, e.code)
-    except Exception as e:
-        return response({
-            "error": "supervisor unavailable",
-            "detail": str(e),
-            "hint": "Run `tina4 serve` (starts the agent server) or set TINA4_SUPERVISOR_URL",
-        }, 503)
-
-    upstream_ct = upstream.headers.get("Content-Type", "") or ""
-
-    # SSE / event-stream: stream chunks through as they arrive. Without
-    # this the SPA sees nothing until the supervisor's entire multi-agent
-    # run completes (30s+), then a wall of events at once — looks like
-    # "Connection failed". urlopen.read(n) is blocking, so each read goes
-    # through asyncio.to_thread to keep the event loop responsive.
-    if "text/event-stream" in upstream_ct.lower():
-        async def _relay():
-            try:
-                while True:
-                    chunk = await asyncio.to_thread(upstream.read, 4096)
-                    if not chunk:
-                        break
-                    yield chunk
-            finally:
-                upstream.close()
-        return response.stream(_relay(), "text/event-stream")
-
-    # JSON / other: drain the body and return as before.
-    try:
-        raw = await asyncio.to_thread(upstream.read)
-    finally:
-        upstream.close()
-    try:
-        return response(json.loads(raw))
-    except Exception:
-        return response(raw.decode("utf-8", errors="replace"))
-
-
-async def _api_supervise_create(request, response):
-    """Before forwarding to the rust agent, auto-flesh the current plan
-    if it has zero steps. The SPA sends the user's supervisor-chat
-    message as ``title``/``plan``; we use that as the fleshing prompt.
-    Skipped when the plan already has steps so populated plans aren't
-    polluted. Best-effort — never blocks supervise/create."""
-    try:
-        from tina4_python.dev_admin import plan as _plan
-        current = _plan.current()
-        is_empty = (
-            isinstance(current.get("current"), str)
-            and (current.get("progress") or {}).get("total", 0) == 0
-        )
-        if is_empty:
-            body = getattr(request, "body", None) or {}
-            if isinstance(body, dict):
-                prompt = str(body.get("plan") or body.get("title") or "").strip()
-                if prompt:
-                    _plan.flesh(current["current"], prompt)
-    except Exception:
-        pass  # Fleshing is best-effort.
-    return await _proxy_to_supervisor(request, response, "/supervise/create")
-
-
-async def _api_supervise_sessions(request, response):
-    return await _proxy_to_supervisor(request, response, "/supervise/sessions")
-
-
-async def _api_supervise_diff(request, response):
-    return await _proxy_to_supervisor(request, response, "/supervise/diff")
-
-
-async def _api_supervise_commit(request, response):
-    return await _proxy_to_supervisor(request, response, "/supervise/commit")
-
-
-async def _api_supervise_cancel(request, response):
-    return await _proxy_to_supervisor(request, response, "/supervise/cancel")
-
-
-async def _api_execute(request, response):
-    return await _proxy_to_supervisor(request, response, "/execute")
-
-
-async def _api_thoughts(request, response):
-    """Thoughts — proxied to the rust agent server when it's running,
-    otherwise an empty list so the SPA renders gracefully."""
-    base = _supervisor_base_url()
-    import urllib.request
-    import urllib.error
-    try:
-        with urllib.request.urlopen(f"{base}/thoughts", timeout=5) as r:
-            raw = r.read()
-        try:
-            return response(json.loads(raw))
-        except Exception:
-            return response({"thoughts": []})
-    except Exception:
-        return response({"thoughts": []})
-
-
 async def _api_ai_proxy(request, response):
     """Transparent pass-through to the qwen ollama chat endpoint.
 
@@ -1798,56 +1611,6 @@ async def _api_feedback_widget_js(request, response):
     return response(body, 200, "application/javascript")
 
 
-async def _api_threads(request, response):
-    """Proxy /__dev/api/threads → Rust agent /threads (GET list, POST create).
-
-    Method-multiplexed handler — the dev_admin dispatcher registered this
-    under the "*" method wildcard so one entry point serves both list and
-    create. Anything other than GET/POST gets a 405.
-    """
-    method = (getattr(request, "method", "GET") or "GET").upper()
-    if method not in ("GET", "POST"):
-        return response({"error": "method not allowed"}, 405)
-    return await _proxy_to_supervisor(request, response, "/threads")
-
-
-async def _api_threads_sub(request, response):
-    """Proxy /__dev/api/threads/{id}[/messages] → Rust agent.
-
-    Catches everything beneath /__dev/api/threads/ via the dispatcher's
-    "/*" prefix match. We strip the dev-admin prefix and forward the
-    remaining path verbatim so /__dev/api/threads/abc/messages becomes
-    /threads/abc/messages on the agent side.
-    """
-    path = getattr(request, "path", "") or ""
-    suffix = path[len("/__dev/api"):]  # leaves "/threads/abc[/messages]"
-    if not suffix.startswith("/threads/"):
-        return response({"error": "not found"}, 404)
-    return await _proxy_to_supervisor(request, response, suffix)
-
-
-async def _api_chat(request, response):
-    """Proxy dev-admin chat to the Rust agent server's /chat endpoint.
-
-    The SPA (Chat.ts) POSTs `{message, settings, files?}` and expects an
-    SSE stream of `event: status / message / done` chunks. The Rust agent
-    runs the supervisor → planner → coder loop, calls the configured LLM
-    (Anthropic / OpenAI / Tina4 Cloud — driven by `ChatSettings` from
-    `.tina4/chat/settings.json` or the ANTHROPIC_API_KEY env-var
-    defaults), and streams progress back.
-
-    Earlier versions of this endpoint called qwen on the Tina4 Cloud
-    directly and returned a single JSON blob, which broke the SPA's SSE
-    reader and bypassed every configured model setting. If you want the
-    bare qwen path it's still reachable at /ai/api/chat.
-
-    When `tina4 agent` isn't running, _proxy_to_supervisor returns 503
-    with a helpful hint so the SPA can show a real error instead of
-    silently hanging.
-    """
-    return await _proxy_to_supervisor(request, response, "/chat")
-
-
 async def _api_tool(request, response):
     """Run a developer tool and return output."""
     import subprocess
@@ -2282,7 +2045,16 @@ def render_dev_toolbar(method: str, path: str, matched_pattern: str,
     path = _html_escape(str(path), quote=True)
     matched_pattern = _html_escape(str(matched_pattern), quote=True)
     request_id = _html_escape(str(request_id), quote=True)
-    no_reload = os.environ.get("TINA4_NO_RELOAD", "").lower() in ("true", "1", "yes") or _ai_port_ctx.get()
+    # The dev-admin dashboard (any /__dev page) owns its OWN gentle reload watcher
+    # inside the SPA (git-status refresh in place), so the toolbar's blunt
+    # location.reload() must be suppressed there -- otherwise saving a file from
+    # the dashboard's editor reloads the whole dashboard and stomps the editing
+    # session. App pages keep the normal hot-reload.
+    no_reload = (
+        os.environ.get("TINA4_NO_RELOAD", "").lower() in ("true", "1", "yes")
+        or _ai_port_ctx.get()
+        or str(path).startswith("/__dev")
+    )
     reload = "0" if no_reload else "1"
 
     return f"""<link rel="stylesheet" href="/__dev/toolbar.css">

{tina4_python-3.13.131 → tina4_python-3.13.133}/tina4_python/frond/compiler.py

@@ -45,35 +45,6 @@ class _Unsupported(Exception):
     so the caller uses the interpreted renderer for the whole template."""
 
 
-def _tostr(value) -> str:
-    """Coerce a rendered value to its output string.
-
-    THE cross-framework output contract, and it MUST stay identical to the
-    interpreter's copy in ``engine.Frond._to_output`` -- the compiled path and the
-    interpreted path have to render the same bytes. Change one, change both.
-
-    A boolean renders lowercase ``true``/``false``: Frond is a template language,
-    not Python, and lowercase is the form usable directly in HTML and JavaScript
-    (``data-active="{{ flag }}"`` -> ``data-active="true"``, testable from JS).
-
-    Breaking in 3.13.87: this used to emit Python's ``True``/``False``. The four
-    frameworks had drifted to four different answers -- Python ``True``/``False``
-    (Jinja2-faithful), PHP ``1``/``''`` (Twig-faithful, with ``false`` rendering as
-    an EMPTY STRING), Ruby inconsistent between a comparison and a bare variable,
-    Node ``true``/``false``. All four now agree; a 72-expression corpus locks it.
-
-    ``is True`` / ``is False`` identity checks are deliberate: ``1 == True`` in
-    Python, and an integer 1 must still render as ``1``.
-    """
-    if value is None:
-        return ""
-    if value is True:
-        return "true"
-    if value is False:
-        return "false"
-    return str(value)
-
-
 def _pad(indent: int) -> str:
     return "    " * indent
 
@@ -99,7 +70,12 @@ def compile_template(ast):
             "_LoopContext": _engine._LoopContext,
             "_eval_expr": _engine._eval_expr,
             "_eval_comparison": _engine._eval_comparison,
-            "_tostr": _tostr,
+            # The compiled path coerces output through the interpreter's OWN
+            # Frond._to_output -- single source of truth for the cross-framework
+            # output contract, so the compiled and interpreted paths cannot drift
+            # (they were byte-identical copies with a "change one, change both"
+            # hazard). Bound here, at compile time, so there is no per-render cost.
+            "_tostr": _engine.Frond._to_output,
             "isinstance": isinstance,
             "list": list,
             "len": len,