webbee 0.3.4__tar.gz → 0.3.6__tar.gz

{webbee-0.3.4 → webbee-0.3.6}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.3.6
+
+- Boot replay shows only the conversation: flattened tool traffic
+  (`[tool_use …]` / `[tool_result] …` blocks the agent keeps as its own
+  working memory) no longer floods the boot screen — each replayed message
+  shows its human-readable part, pure tool messages are skipped.
+
+## 0.3.5
+
+- Surface-aware conversation: turns steered from Telegram/the panel render
+  live in the terminal tagged by origin (`[telegram]` / `[web-panel]`) —
+  the terminal stays the session's sole executor, foreign turns are
+  display-only and are never executed locally.
+- Boot replay: opening the terminal replays the recent conversation
+  (including cross-surface turns) with origin tags, then a "— live —"
+  divider. Best-effort — a network failure never blocks boot.
+
 ## 0.3.4
 
 - `/notify [tg|panel|both|off]` — mirror this coding session to Telegram

{webbee-0.3.4 → webbee-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.4
+Version: 0.3.6
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.4 → webbee-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.4"
+version = "0.3.6"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.6/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.6"

{webbee-0.3.4 → webbee-0.3.6}/src/webbee/frames.py

@@ -123,6 +123,61 @@ def handle_action_frame(frame: dict, sink, started: set, finished: set, steps: l
     steps.append({"step_id": sid, "label": lbl, "ok": ok})
 
 
+# --- Cross-surface (foreign-turn) frames -------------------------------------
+# Frames stamped with a DIFFERENT task_id belong to another turn on the shared
+# persistent stream -- a turn steered from Telegram/the panel (kernel stamps
+# `origin` with the source surface) or a stale prior turn (no `origin`). They
+# are DISPLAY-ONLY for this client: one tagged line, NEVER executed, NEVER
+# consented, NEVER terminal for the client's own turn (the C7 safety filter in
+# session.run() owns that guarantee; these helpers only compose the line).
+
+_FOREIGN_ACTIONABLE_TYPES = ("tool_request", "confirm_request", "final",
+                             "marathon_complete", "panel_release_required")
+
+
+def _origin_tag(frame: dict) -> str:
+    """Display prefix for an OWN-turn frame steered from another surface.
+    Live steer topology: a Telegram/panel-steered turn keeps the terminal's
+    OWN task_id (the terminal stays the sole executor) -- only the kernel-
+    stamped `origin` says where it came from. Empty for terminal/own frames,
+    so untagged rendering stays byte-identical to today."""
+    origin = str(frame.get("origin", "") or "")
+    return f"[{origin}] " if origin and origin != "terminal" else ""
+
+
+def _foreign_note(frame: dict) -> str:
+    """One-line display text for a cross-surface frame, or "" when there is
+    nothing meaningful to show (usage/step bookkeeping/unknown types) -- the
+    caller then skips it silently."""
+    ftype = frame.get("type", "")
+    tool = str(frame.get("tool", "") or "")
+    if ftype == "tool_request":
+        return f"running {tool}" if tool else "running a tool"
+    if ftype == "confirm_request":
+        return f"approval requested: {tool}" if tool else "approval requested"
+    if ftype in ("final", "marathon_complete", "progress", "thinking"):
+        return _progress_text(frame).strip()
+    if ftype == "panel_release_required":
+        summary = str(frame.get("summary", "") or "").strip()
+        return summary or "payment approval required in the panel"
+    return ""
+
+
+def render_foreign_frame(frame: dict, sink) -> None:
+    """Render ONE tagged, display-only line for a foreign-turn frame. Guarded
+    like the marathon notes: a minimal sink without `foreign_turn` drops the
+    line, and a render error must never break the safety `continue` in
+    session.run() (rendering is the ONLY thing foreign frames ever get)."""
+    text = _foreign_note(frame)
+    render = getattr(sink, "foreign_turn", None)
+    if not text or render is None:
+        return
+    try:
+        render(str(frame.get("origin", "") or ""), "assistant", text)
+    except Exception:
+        pass
+
+
 # --- U4 marathon FACT frames -------------------------------------------------
 # A marathon (long-horizon autonomous run) streams the SAME frame vocabulary as
 # a coding turn PLUS three progress FACTS. The kernel emits facts; this renderer

{webbee-0.3.4 → webbee-0.3.6}/src/webbee/render.py

@@ -222,6 +222,17 @@ class RichSink:
         self.console.print(_pad(Text(" ❯ " + _clean(text) + " ", style="bold white on grey30")))
         self._nudge()
 
+    def foreign_turn(self, surface: str, role: str, text: str) -> None:
+        """One tagged line for a turn that lives on ANOTHER surface (a
+        Telegram/panel-steered turn on the shared stream, or a replayed prior
+        turn). DISPLAY-ONLY: never touches _tools/tokens/_busy, so the
+        terminal's own turn accounting stays uncontaminated."""
+        who = "you" if role == "user" else "🐝 webbee"
+        surface = _clean(surface)
+        tag = "" if surface in ("", "terminal") else f" [{surface}]"
+        self.console.print(_pad(Text(f"{who}{tag}: {_clean(text)}", style=_BEE)))
+        self._nudge()
+
     def clear(self) -> None:
         """/clear: wipe the pane/screen + reset the session counters."""
         self.console.clear()

{webbee-0.3.4 → webbee-0.3.6}/src/webbee/repl.py

@@ -291,6 +291,27 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         account = await account_fetcher(cfg, token_provider)
         state["logged_in"] = account.signed_in
         _sink.welcome(account, workspace, "terminal")
+        # Boot replay of the durable per-user thread (Task 9): best-effort,
+        # entirely swallowed on any failure -- history is a nice-to-have,
+        # never a boot blocker (network down, no such session yet, etc.).
+        try:
+            from imperal_mcp.client import ImperalClient
+            from webbee.thread import (conversational_text, fetch_recent_thread,
+                                       truncate_for_display)
+            _iid = await ImperalClient(cfg, token_provider).whoami()
+            _msgs = await fetch_recent_thread(cfg, token_provider, f"marathon-{_iid}-rboot")
+            _shown = 0
+            for _m in _msgs[-40:]:
+                _text = conversational_text(_m.get("content", ""))
+                if not _text:
+                    continue  # pure tool traffic -- mind-food, not conversation
+                _sink.foreign_turn(_m.get("surface", "terminal"), _m.get("role", ""),
+                                   truncate_for_display(_text))
+                _shown += 1
+            if _shown:
+                _sink.note("— live —")
+        except Exception:
+            pass  # replay is best-effort; never block boot
         if cfg.intel_enabled:
             # Off-loop build (indexing does sync file I/O + subprocess). Any
             # failure here (missing extra, bad repo, etc.) must degrade to

{webbee-0.3.4 → webbee-0.3.6}/src/webbee/session.py

@@ -3,13 +3,16 @@ import os
 import subprocess
 
 from webbee.frames import (
+    _FOREIGN_ACTIONABLE_TYPES,
     _MARATHON_FACT_TYPES,
     _first_time,
+    _origin_tag,
     _progress_text,
     handle_action_frame,
     handle_step_finished,
     handle_step_started,
     marathon_note,
+    render_foreign_frame,
 )
 
 
@@ -218,13 +221,23 @@ class AgentSession:
                 ftype = frame.get("type")
 
                 _ftid = frame.get("task_id", "")
-                # Ignore actionable frames from a DIFFERENT turn on the shared
-                # persistent stream (task_id absent on legacy kernels -> not filtered).
-                if _ftid and self._task_id and _ftid != self._task_id and ftype in (
-                        "tool_request", "confirm_request", "final",
-                        "marathon_complete", "panel_release_required"):
+                # A frame from a DIFFERENT turn on the shared persistent stream
+                # (task_id absent on legacy kernels -> treated as own). C7 safety:
+                # foreign actionable frames are NEVER executed/consented and NEVER
+                # end this turn -- but instead of vanishing they (and any origin-
+                # stamped cross-surface display frame, e.g. a Telegram-steered
+                # turn's progress) now render ONE tagged, display-only line.
+                if _ftid and self._task_id and _ftid != self._task_id and (
+                        frame.get("origin") or ftype in _FOREIGN_ACTIONABLE_TYPES):
+                    render_foreign_frame(frame, sink)
                     continue
 
+                # Live steer topology: a Telegram/panel-steered turn keeps THIS
+                # client's task_id (the terminal stays the sole executor) with
+                # `origin` stamped -- tag the text renders below; everything
+                # else (execution, dedup, consent, accounting) is unchanged.
+                _tag = _origin_tag(frame)
+
                 if ftype == "tool_request":
                     rid = frame.get("req_id")
                     sid = str(rid or "")
@@ -236,14 +249,14 @@ class AgentSession:
                         # dispatch and freezes the dock).
                         if _first_time(sid, started):
                             try:
-                                sink.tool_start(frame.get("tool", ""), frame.get("args", {}))
+                                sink.tool_start(_tag + frame.get("tool", ""), frame.get("args", {}))
                             except Exception:
                                 pass
                         out = await asyncio.to_thread(handle_tool_request, frame, executor)
                         res = out["result"]
                         if _first_time(sid, finished):
                             try:
-                                sink.tool_result(frame.get("tool", ""), bool(res.get("ok")), _summary(res))
+                                sink.tool_result(_tag + frame.get("tool", ""), bool(res.get("ok")), _summary(res))
                                 self.steps.append({"step_id": sid,
                                                    "label": frame.get("tool", ""),
                                                    "ok": bool(res.get("ok"))})
@@ -276,10 +289,12 @@ class AgentSession:
                     handle_step_finished(frame, sink, finished, step_labels, self.steps, local_ids)
 
                 elif ftype == "thinking":  # system-driven reasoning -> the 💭 block
-                    (getattr(sink, "thinking", None) or sink.progress)(_progress_text(frame))
+                    _text = _progress_text(frame)
+                    (getattr(sink, "thinking", None) or sink.progress)(_tag + _text if _text else "")
 
                 elif ftype == "progress":  # P2 — dual-reads llm_text (v2) / text (legacy)
-                    sink.progress(_progress_text(frame))
+                    _text = _progress_text(frame)
+                    sink.progress(_tag + _text if _text else "")
 
                 elif ftype == "usage":  # P2 — cumulative tokens + credits (Slice C; raw $ stays server-side)
                     sink.usage(
@@ -311,7 +326,8 @@ class AgentSession:
                     # non-marathon coding turn's `final` is terminal (unchanged).
                     if marathon and not frame.get("stopped"):
                         continue
-                    return frame.get("text", "")
+                    _text = frame.get("text", "")
+                    return _tag + _text if _text else ""
 
         return ""
 

webbee-0.3.6/src/webbee/thread.py

@@ -0,0 +1,49 @@
+"""Fetch the durable coding-thread transcript for boot replay. The gateway
+keeps ONE durable per-user thread across turns/surfaces (session.py:142,
+"server reloads the shared webbee-terminal thread, so context carries across
+turns"); this reads its recent tail so `_boot` can replay it with origin tags
+before the live loop starts. House pattern = sessions.py/remote.py: (cfg,
+token_provider), lazy httpx, Bearer auth. This module does not swallow errors
+itself -- `_boot` wraps the whole replay in one try/except so a network
+failure never blocks/delays boot beyond the timeout, it just skips the
+replay (same division of labor as remote.py + the /notify call site)."""
+from __future__ import annotations
+
+_DISPLAY_LIMIT = 400
+
+# The durable thread stores each tool exchange FLATTENED into the message
+# text ("[tool_use bash] {...}" / "[tool_result] ..."), so the agent can
+# reread its own past work. That is mind-food, not conversation -- replaying
+# it verbatim floods the boot screen with raw JSON (Valentin, live
+# 2026-07-15). Replay shows only the conversational part of each message.
+_FLATTEN_MARKERS = ("[tool_use ", "[tool_result]")
+
+
+def conversational_text(content) -> str:
+    """The human-conversation part of one stored thread message: everything
+    up to the first flattened tool block, stripped. "" means the message was
+    pure tool traffic and must be skipped by the replay."""
+    text = str(content or "")
+    cut = len(text)
+    for m in _FLATTEN_MARKERS:
+        i = text.find(m)
+        if i != -1:
+            cut = min(cut, i)
+    return text[:cut].strip()
+
+
+async def fetch_recent_thread(cfg, token_provider, session_id: str) -> list[dict]:
+    import httpx
+    token = await token_provider()
+    async with httpx.AsyncClient(base_url=cfg.api_url, timeout=10) as c:
+        r = await c.get(f"/v1/agent/sessions/{session_id}/thread",
+                        headers={"Authorization": f"Bearer {token}"})
+        r.raise_for_status()
+        return (r.json() or {}).get("messages", [])
+
+
+def truncate_for_display(text, limit: int = _DISPLAY_LIMIT) -> str:
+    """Cap one replayed message's text so a single huge assistant reply can't
+    flood the boot screen -- foreign_turn renders one line per message."""
+    text = str(text or "")
+    return text if len(text) <= limit else text[:limit].rstrip() + "…"

{webbee-0.3.4 → webbee-0.3.6}/tests/test_render.py

@@ -246,6 +246,34 @@ def test_user_echo_is_unboxed_line():
     assert "╭" not in out and "│" not in out and "╰" not in out   # NOT the input box
 
 
+def test_foreign_turn_tagged_line_no_turn_accounting():
+    # A cross-surface line is DISPLAY-ONLY: tagged by origin surface, empty
+    # tag for terminal/replay-own, and it must NOT touch the terminal's own
+    # turn accounting (_tools/tokens/_busy) -- recon §3's contamination risk.
+    s = _sink()
+    s.begin_turn()
+    tools, tokens, busy = s._tools, s.tokens, s._busy
+    s.foreign_turn("telegram", "assistant", "done on telegram")
+    s.foreign_turn("terminal", "user", "fix the tests")
+    s.foreign_turn("", "assistant", "stale line")
+    out = s.console.export_text()
+    assert "🐝 webbee [telegram]: done on telegram" in out
+    assert "you: fix the tests" in out                  # terminal -> no tag
+    assert "[terminal]" not in out
+    assert "🐝 webbee: stale line" in out               # empty surface -> no tag
+    assert (s._tools, s.tokens, s._busy) == (tools, tokens, busy)
+    assert not NO_CYRILLIC.search(out)
+
+
+def test_foreign_turn_strips_control_bytes():
+    # Kernel-relayed text is untrusted -- same _clean rule as note()/tool lines.
+    s = _sink()
+    s.foreign_turn("tele\x1b[2Jgram", "assistant", "hi\x1b]0;pwned\x07 there")
+    out = s.console.export_text()
+    assert "\x1b[2J" not in out and "pwned" not in out
+    assert "[telegram]" in out and "hi there" in out
+
+
 def test_answer_marker_shows_webbee_name():
     s = _sink()
     s.begin_turn(); s.end_turn("here is the answer")

{webbee-0.3.4 → webbee-0.3.6}/tests/test_repl.py

@@ -20,6 +20,8 @@ class FakeSink:
     def welcome(self, *a, **kw): ...
     def user_echo(self, text): self.echoed = getattr(self, "echoed", []) + [text]
     def sessions_table(self, rows): self.session_tables = getattr(self, "session_tables", []) + [rows]
+    def foreign_turn(self, surface, role, text):
+        self.foreign = getattr(self, "foreign", []) + [(surface, role, text)]
     # TurnSink no-ops
     def tool_start(self, *a): ...
     def tool_result(self, *a): ...
@@ -473,3 +475,97 @@ def test_watcher_started_at_intel_root_not_workspace(monkeypatch, tmp_path):
     ))
     assert captured.get("root") == str(tmp_path)
     assert captured.get("root") != os.getcwd()
+
+
+# ── boot replay of the durable coding thread (Task 9) ─────────────────────────
+
+class _FakeImperalClient:
+    """Stands in for imperal_mcp.client.ImperalClient -- house pattern already
+    used by test_session.py/test_marathon.py for the same external class."""
+    def __init__(self, cfg, token_provider):
+        pass
+
+    async def whoami(self):
+        return "user-1"
+
+
+def test_boot_replays_recent_thread_before_live_loop(monkeypatch):
+    import imperal_mcp.client as ic
+    import webbee.thread as TH
+
+    monkeypatch.setattr(ic, "ImperalClient", _FakeImperalClient)
+
+    async def fake_fetch(cfg, token_provider, session_id):
+        assert session_id == "marathon-user-1-rboot"     # _owns prefix contract
+        return [
+            {"role": "user", "content": "hi", "surface": "telegram"},
+            {"role": "assistant", "content": "done", "surface": "terminal"},
+        ]
+    monkeypatch.setattr(TH, "fetch_recent_thread", fake_fetch)
+
+    sink, agent = _run(read_line=_lines("/exit"))
+    assert sink.foreign == [
+        ("telegram", "user", "hi"),           # renders as "you [telegram]: hi"
+        ("terminal", "assistant", "done"),
+    ]
+    assert any("live" in n for n in sink.notes)
+    # replay happened during boot, strictly before any turn ran
+    assert agent.tasks == []
+
+
+def test_boot_replay_survives_thread_fetch_failure(monkeypatch):
+    import imperal_mcp.client as ic
+    import webbee.thread as TH
+
+    monkeypatch.setattr(ic, "ImperalClient", _FakeImperalClient)
+
+    async def boom(cfg, token_provider, session_id):
+        raise RuntimeError("connection refused")
+    monkeypatch.setattr(TH, "fetch_recent_thread", boom)
+
+    sink, agent = _run(read_line=_lines("hello", "/exit"))
+    assert getattr(sink, "foreign", []) == []
+    assert agent.tasks == ["hello"]            # boot completed cleanly, agent still works
+
+
+def test_boot_replay_survives_whoami_failure(monkeypatch):
+    # No imperal_mcp.client.ImperalClient patched here -- whoami() hits the
+    # (unreachable) fake api_url and raises. The whole replay block must be
+    # swallowed, never crashing boot or delaying it past the intel/agent setup.
+    sink, agent = _run(read_line=_lines("hello", "/exit"))
+    assert getattr(sink, "foreign", []) == []
+    assert agent.tasks == ["hello"]
+
+
+def test_boot_replay_truncates_long_messages(monkeypatch):
+    import imperal_mcp.client as ic
+    import webbee.thread as TH
+
+    monkeypatch.setattr(ic, "ImperalClient", _FakeImperalClient)
+
+    long_text = "x" * 1000
+
+    async def fake_fetch(cfg, token_provider, session_id):
+        return [{"role": "assistant", "content": long_text, "surface": "terminal"}]
+    monkeypatch.setattr(TH, "fetch_recent_thread", fake_fetch)
+
+    sink, agent = _run(read_line=_lines("/exit"))
+    assert len(sink.foreign) == 1
+    rendered = sink.foreign[0][2]
+    assert len(rendered) <= 401                 # 400 chars + ellipsis
+    assert rendered.endswith("…")
+
+
+def test_boot_replay_skips_note_when_thread_empty(monkeypatch):
+    import imperal_mcp.client as ic
+    import webbee.thread as TH
+
+    monkeypatch.setattr(ic, "ImperalClient", _FakeImperalClient)
+
+    async def fake_fetch(cfg, token_provider, session_id):
+        return []
+    monkeypatch.setattr(TH, "fetch_recent_thread", fake_fetch)
+
+    sink, agent = _run(read_line=_lines("/exit"))
+    assert getattr(sink, "foreign", []) == []
+    assert not any("live" in n for n in sink.notes)

{webbee-0.3.4 → webbee-0.3.6}/tests/test_session.py

@@ -137,10 +137,22 @@ def test_run_ignores_foreign_turn_actionable_frames_ends_on_own_final(monkeypatc
     monkeypatch.setattr(T, "LocalToolExecutor", _RecExecutor)
 
     async def _fake_stream(client, session_id, headers_provider, *, start_id="0-0"):
-        # A foreign turn's tool_request and final (must be ignored), THEN
-        # this turn's own final (must be honored).
+        # A foreign turn's tool_request and final (must NEVER be executed /
+        # terminal for THIS turn -- only rendered as tagged lines), THEN this
+        # turn's own final (must be honored). Cross-surface frames carry the
+        # kernel-stamped `origin`; a stale prior-turn frame carries none.
         yield {"type": "tool_request", "task_id": "OTHER", "req_id": "r1",
                "tool": "read_file", "args": {}}
+        yield {"type": "tool_request", "task_id": "TG", "req_id": "r2",
+               "tool": "write_file", "args": {}, "origin": "telegram"}
+        yield {"type": "confirm_request", "task_id": "TG", "req_id": "r3",
+               "tool": "bash", "args": {}, "origin": "telegram"}
+        yield {"type": "progress", "task_id": "TG", "text": "thinking it over",
+               "origin": "telegram"}
+        yield {"type": "usage", "task_id": "TG", "tokens": 5, "credits": 1,
+               "origin": "telegram"}  # nothing to show -> silently skipped
+        yield {"type": "final", "task_id": "TG", "text": "done on telegram",
+               "origin": "telegram"}
         yield {"type": "final", "task_id": "OTHER", "text": "wrong turn"}
         yield {"type": "final", "task_id": "OURS", "text": "done"}
 
@@ -168,22 +180,165 @@ def test_run_ignores_foreign_turn_actionable_frames_ends_on_own_final(monkeypatc
     monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
 
     class RecSink:
+        def __init__(self):
+            self.foreign = []; self.progress_calls = []; self.usage_calls = []
         def tool_start(self, *a): ...
         def tool_result(self, *a): ...
         def ask_consent(self, *a): return "y"
         def panel_release(self, *a): ...
-        def progress(self, *a): ...
-        def usage(self, *a): ...
+        def progress(self, text): self.progress_calls.append(text)
+        def usage(self, *a): self.usage_calls.append(a)
+        def foreign_turn(self, surface, role, text): self.foreign.append((surface, role, text))
 
     async def token_provider():
         return "tok"
 
     sess = S.AgentSession(cfg=_FakeCfg(), token_provider=token_provider, workspace_root=".")
-    result = asyncio.run(sess.run("do it", RecSink()))
+    sink = RecSink()
+    result = asyncio.run(sess.run("do it", sink))
+
+    assert result == "done"                # ended on OUR final, not a foreign one
+    assert executor_calls == []            # foreign tool_requests never dispatched
+    assert posts == ["/v1/agent/sessions"]  # no /result POST for the foreign frames
+    # Cross-surface/stale frames render as DISPLAY-ONLY tagged lines (origin
+    # tag; empty for a stale/legacy frame) -- and nothing else happens.
+    assert sink.foreign == [
+        ("", "assistant", "running read_file"),
+        ("telegram", "assistant", "running write_file"),
+        ("telegram", "assistant", "approval requested: bash"),
+        ("telegram", "assistant", "thinking it over"),
+        ("telegram", "assistant", "done on telegram"),
+        ("", "assistant", "wrong turn"),
+    ]
+    assert sink.progress_calls == []       # foreign progress never leaks into the own feed
+    assert sink.usage_calls == []          # foreign usage: nothing to show, nothing counted
+
+
+def test_own_turn_frames_with_cross_surface_origin_render_tagged_and_execute(monkeypatch):
+    # Live steer topology (final review C1): a Telegram-steered turn keeps the
+    # terminal's OWN task_id (the kernel drain adopts it -- the terminal stays
+    # the sole executor) and stamps `origin` with the source surface. The own
+    # path must behave EXACTLY as today (execute once, dedup, accounting,
+    # consent flow untouched) with the surface tag prefixed onto the text
+    # renders; own frames WITHOUT origin render byte-identical to today.
+    import httpx
+    import imperal_mcp.client as ic
+    import webbee.session as S
+    import webbee.stream as ST
+    import webbee.tools as T
+
+    monkeypatch.setattr(S, "build_coding_context", lambda root, intel=None: {
+        "cwd": root, "git": "", "tree": "", "repo_key": "x", "repo_root": root,
+    })
+
+    class _FakeImperalClient:
+        def __init__(self, cfg, token_provider):
+            pass
+
+        async def whoami(self):
+            return "user-1"
+
+    monkeypatch.setattr(ic, "ImperalClient", _FakeImperalClient)
+
+    executor_calls = []
+
+    class _RecExecutor:
+        def __init__(self, root, indexer=None, shadow=None):
+            pass
+
+        def run(self, tool, args):
+            executor_calls.append((tool, args))
+            return {"ok": True, "content": "ran"}
+
+    monkeypatch.setattr(T, "LocalToolExecutor", _RecExecutor)
+
+    async def _fake_stream(client, session_id, headers_provider, *, start_id="0-0"):
+        yield {"type": "tool_request", "task_id": "OURS", "req_id": "r1",
+               "tool": "read_file", "args": {}, "origin": "telegram"}
+        yield {"type": "tool_request", "task_id": "OURS", "req_id": "r1",
+               "tool": "read_file", "args": {}, "origin": "telegram"}  # dup req_id -> dedup
+        yield {"type": "tool_request", "task_id": "OURS", "req_id": "r2",
+               "tool": "write_file", "args": {}}                       # no origin -> untagged
+        yield {"type": "progress", "task_id": "OURS", "text": "editing files",
+               "origin": "telegram"}
+        yield {"type": "thinking", "task_id": "OURS", "llm_text": "pondering",
+               "origin": "telegram"}
+        yield {"type": "progress", "task_id": "OURS", "text": "plain progress"}
+        yield {"type": "progress", "task_id": "OURS", "text": "own terminal line",
+               "origin": "terminal"}                                    # own surface -> no tag
+        yield {"type": "progress", "task_id": "OURS", "text": "",
+               "origin": "telegram"}   # empty text -> stays empty, no lone tag line
+        yield {"type": "final", "task_id": "OURS", "text": "steered done",
+               "origin": "telegram"}
+
+    monkeypatch.setattr(ST, "stream_frames", _fake_stream)
+
+    class _SessResp:
+        def raise_for_status(self): pass
+        def json(self): return {"session_id": "sid1", "last_id": "0-0", "task_id": "OURS"}
+
+    class _ResultResp:
+        def raise_for_status(self): pass
+        def json(self): return {}
+
+    posts = []
+
+    class FakeAsyncClient:
+        def __init__(self, *a, **kw): pass
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): return False
+
+        async def post(self, path, headers=None, **kw):
+            posts.append(path)
+            return _SessResp() if path == "/v1/agent/sessions" else _ResultResp()
+
+    monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
 
-    assert result == "done"                # ended on OUR final, not the foreign one
-    assert executor_calls == []            # foreign tool_request never dispatched
-    assert posts == ["/v1/agent/sessions"]  # no /result POST for the ignored frames
+    class RecSink:
+        def __init__(self):
+            self.starts = []; self.results = []; self.progress_calls = []; self.foreign = []
+        def tool_start(self, tool, args): self.starts.append((tool, dict(args)))
+        def tool_result(self, tool, ok, summary): self.results.append((tool, ok, summary))
+        def ask_consent(self, *a): return "y"
+        def panel_release(self, *a): ...
+        def progress(self, text): self.progress_calls.append(text)
+        def usage(self, *a): ...
+        def foreign_turn(self, surface, role, text): self.foreign.append((surface, role, text))
+
+    async def token_provider():
+        return "tok"
+
+    sess = S.AgentSession(cfg=_FakeCfg(), token_provider=token_provider, workspace_root=".")
+    sink = RecSink()
+    result = asyncio.run(sess.run("do it", sink))
+
+    assert result == "[telegram] steered done"      # final text carries the tag
+    # Execution/dedup/accounting IDENTICAL to today: each req_id runs once,
+    # the dup re-posts the cached result (at-least-once), steps record cleanly.
+    assert executor_calls == [("read_file", {}), ("write_file", {})]
+    assert posts[0] == "/v1/agent/sessions"
+    assert posts.count("/v1/agent/sessions/sid1/result") == 3  # r1, r1-dup, r2
+    assert sess.steps == [
+        {"step_id": "r1", "label": "read_file", "ok": True},
+        {"step_id": "r2", "label": "write_file", "ok": True},
+    ]
+    # Tool lines: tagged when steered, untagged otherwise.
+    assert sink.starts == [("[telegram] read_file", {}), ("write_file", {})]
+    assert sink.results == [("[telegram] read_file", True, "ran"),
+                            ("write_file", True, "ran")]
+    # Text lines: tagged when steered; no stray tag for no-origin/terminal.
+    assert sink.progress_calls == ["[telegram] editing files", "[telegram] pondering",
+                                   "plain progress", "own terminal line", ""]
+    assert sink.foreign == []                        # own-path never routes via foreign_turn
+
+
+def test_origin_tag_prefix_only_for_other_surfaces():
+    from webbee.frames import _origin_tag
+    assert _origin_tag({"origin": "telegram"}) == "[telegram] "
+    assert _origin_tag({"origin": "web-panel"}) == "[web-panel] "
+    assert _origin_tag({"origin": "terminal"}) == ""   # own surface
+    assert _origin_tag({"origin": ""}) == ""
+    assert _origin_tag({}) == ""
 
 
 def test_action_frame_maps_to_feed():
@@ -260,6 +415,36 @@ def test_summary_from_facts_pluralizes_with_entity_kind_when_present():
     assert _summary_from_facts({"count": 3, "entity_kind": "message"}) == "3 messages"
 
 
+def test_render_foreign_frame_is_display_only_and_never_raises():
+    # Cross-surface frames (Telegram/panel steering) get ONE tagged line and
+    # NOTHING else. The render side effect must never break the safety
+    # `continue` in session.run(): a sink without foreign_turn drops the line;
+    # a sink whose foreign_turn raises is swallowed.
+    from webbee.frames import render_foreign_frame
+
+    class Rec:
+        def __init__(self): self.calls = []
+        def foreign_turn(self, surface, role, text): self.calls.append((surface, role, text))
+
+    r = Rec()
+    render_foreign_frame({"type": "tool_request", "tool": "bash", "origin": "web-panel"}, r)
+    assert r.calls == [("web-panel", "assistant", "running bash")]
+    render_foreign_frame({"type": "usage", "tokens": 1, "origin": "telegram"}, r)
+    assert len(r.calls) == 1               # nothing meaningful to show -> skipped
+    render_foreign_frame({"type": "final", "text": "", "origin": "telegram"}, r)
+    assert len(r.calls) == 1               # empty final text -> skipped
+    render_foreign_frame({"type": "progress", "llm_text": "planning", "origin": "telegram"}, r)
+    assert r.calls[-1] == ("telegram", "assistant", "planning")
+
+    class Bare:                            # minimal sink (no foreign_turn) -> no-op
+        pass
+    render_foreign_frame({"type": "final", "text": "x", "origin": "telegram"}, Bare())
+
+    class Boom:
+        def foreign_turn(self, *a): raise RuntimeError("ui bug")
+    render_foreign_frame({"type": "final", "text": "x", "origin": "telegram"}, Boom())
+
+
 def test_handle_step_started_calls_tool_start_once():
     from webbee.frames import handle_step_started
     sink = RecSink()

webbee-0.3.6/tests/test_thread.py

@@ -0,0 +1,153 @@
+import asyncio
+
+import httpx
+
+from webbee.thread import fetch_recent_thread, truncate_for_display
+
+
+class _Cfg:
+    api_url = "http://x"
+
+
+async def _tp():
+    return "tok"
+
+
+def test_fetch_recent_thread_gets_right_path_and_bearer(monkeypatch):
+    seen = {}
+
+    class _Resp:
+        def raise_for_status(self):
+            pass
+
+        def json(self):
+            return {"messages": [{"role": "user", "content": "hi", "surface": "telegram"}]}
+
+    class FakeAsyncClient:
+        def __init__(self, *a, **kw):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        async def get(self, path, headers=None, **kw):
+            seen["path"] = path
+            seen["headers"] = headers
+            return _Resp()
+
+    monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
+    out = asyncio.run(fetch_recent_thread(_Cfg(), _tp, "marathon-user-1-rboot"))
+    assert seen["path"] == "/v1/agent/sessions/marathon-user-1-rboot/thread"
+    assert seen["headers"] == {"Authorization": "Bearer tok"}
+    assert out == [{"role": "user", "content": "hi", "surface": "telegram"}]
+
+
+def test_fetch_recent_thread_empty_response_returns_empty_list(monkeypatch):
+    class _Resp:
+        def raise_for_status(self):
+            pass
+
+        def json(self):
+            return None
+
+    class FakeAsyncClient:
+        def __init__(self, *a, **kw):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        async def get(self, path, headers=None, **kw):
+            return _Resp()
+
+    monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
+    assert asyncio.run(fetch_recent_thread(_Cfg(), _tp, "marathon-user-1-rboot")) == []
+
+
+def test_fetch_recent_thread_propagates_network_error():
+    # No transport mocked -- unreachable host raises. This module never
+    # swallows errors itself; the caller (`_boot`) owns the best-effort
+    # try/except (same division of labor as remote.py + get_step_detail's
+    # non-swallowing siblings in this package).
+    class _UnreachableCfg:
+        api_url = "http://127.0.0.1:1"
+
+    try:
+        asyncio.run(fetch_recent_thread(_UnreachableCfg(), _tp, "marathon-user-1-rboot"))
+        assert False, "expected a network error to propagate"
+    except Exception:
+        pass
+
+
+def test_fetch_recent_thread_raises_on_http_error(monkeypatch):
+    class _Resp:
+        def raise_for_status(self):
+            raise httpx.HTTPStatusError("boom", request=None, response=None)
+
+    class FakeAsyncClient:
+        def __init__(self, *a, **kw):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        async def get(self, path, headers=None, **kw):
+            return _Resp()
+
+    monkeypatch.setattr(httpx, "AsyncClient", FakeAsyncClient)
+    try:
+        asyncio.run(fetch_recent_thread(_Cfg(), _tp, "marathon-user-1-rboot"))
+        assert False, "expected raise_for_status's error to propagate"
+    except httpx.HTTPStatusError:
+        pass
+
+
+def test_truncate_for_display_short_text_unchanged():
+    assert truncate_for_display("hello") == "hello"
+
+
+def test_truncate_for_display_none_becomes_empty_string():
+    assert truncate_for_display(None) == ""
+
+
+def test_truncate_for_display_long_text_capped_with_ellipsis():
+    text = "a" * 1000
+    out = truncate_for_display(text)
+    assert len(out) == 401           # 400 chars + ellipsis
+    assert out.endswith("…")
+    assert out[:400] == "a" * 400
+
+
+def test_truncate_for_display_respects_custom_limit():
+    assert truncate_for_display("abcdef", limit=3) == "abc…"
+
+
+def test_conversational_text_plain_message_untouched():
+    from webbee.thread import conversational_text
+    assert conversational_text("почини тесты") == "почини тесты"
+
+
+def test_conversational_text_pure_tool_traffic_skipped():
+    from webbee.thread import conversational_text
+    assert conversational_text('[tool_result] {"content": "COMPILE_OK", "ok": true}') == ""
+    assert conversational_text('[tool_use bash] {"command": "pytest -q"}') == ""
+
+
+def test_conversational_text_narration_kept_tool_tail_cut():
+    from webbee.thread import conversational_text
+    mixed = 'Всё компилируется чисто. Теперь коммичу.\n[tool_use bash] {"command": "git push"}'
+    assert conversational_text(mixed) == "Всё компилируется чисто. Теперь коммичу."
+
+
+def test_conversational_text_none_is_empty():
+    from webbee.thread import conversational_text
+    assert conversational_text(None) == ""

webbee-0.3.4/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.4"