aru-code 0.48.0__tar.gz → 0.52.0__tar.gz

{aru_code-0.48.0/aru_code.egg-info → aru_code-0.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.48.0
+Version: 0.52.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.52.0/aru/__init__.py

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

{aru_code-0.48.0 → aru_code-0.52.0}/aru/config.py

@@ -180,6 +180,16 @@ class AgentConfig:
     # Formatter config per language (Tier 3 #1). Same shape as `lsp`, plus
     # an `enabled` top-level boolean to flip auto-format on/off in aggregate.
     format: dict[str, Any] = field(default_factory=dict)
+    # TUI theme name (one of the presets in `aru/tui/themes.py`). When unset
+    # the App keeps Textual's default. Hot-reloadable via the `/theme` slash
+    # command, but the persisted choice lives in `aru.json`.
+    theme: str = ""
+    # OS notification policy: "off" | "background" | "long" | "always".
+    # See `aru/tui/notifications.py` for the threshold logic.
+    notify: str = "background"
+    # Minimum turn duration (seconds) to ring the bell when `notify: long`
+    # or `notify: always`. Default 30s — short turns don't warrant a chime.
+    notify_threshold_sec: float = 30.0
 
     @property
     def has_instructions(self) -> bool:
@@ -545,6 +555,19 @@ def _apply_config_data(config: AgentConfig, data: dict, root: Path) -> None:
         config.lsp = data["lsp"]
     if "format" in data and isinstance(data["format"], dict):
         config.format = data["format"]
+    if "theme" in data and isinstance(data["theme"], str):
+        config.theme = data["theme"].strip()
+    if "notify" in data and isinstance(data["notify"], str):
+        nv = data["notify"].strip().lower()
+        if nv in ("off", "background", "long", "always"):
+            config.notify = nv
+    if "notify_threshold_sec" in data:
+        try:
+            v = float(data["notify_threshold_sec"])
+            if v > 0:
+                config.notify_threshold_sec = v
+        except (TypeError, ValueError):
+            pass
     if "instructions" in data and isinstance(data["instructions"], list):
         entries = [str(e) for e in data["instructions"] if isinstance(e, str)]
         config.rules_instructions = _resolve_instructions(entries, root)

{aru_code-0.48.0 → aru_code-0.52.0}/aru/display.py

@@ -25,7 +25,7 @@ aru_logo = """
 """
 
 neon_green = "#39ff14"
-shadow_green = "#042800"
+shadow_green = "#073e00"
 
 
 def _build_logo_with_shadow(logo_text: str) -> Text:

aru_code-0.52.0/aru/doom_loop.py

@@ -0,0 +1,137 @@
+"""Doom-loop detection: catch agents stuck repeating identical tool calls.
+
+A *doom-loop* is the agent invoking the same tool with the same arguments
+N times in a row, with no intervening different call. The model has lost
+the plot — typically because a tool kept failing and the model forgot it
+already tried that exact thing — and without intervention the run will
+just burn budget until the context window fills.
+
+This module gives the runner a cheap, deterministic detector. The
+heuristic mirrors OpenCode's ``session/processor.ts:188-211``:
+
+* keep a sliding window of the last N (tool_name, sorted-args) pairs;
+* when the window is full and every entry equals the latest one, fire.
+
+When detection fires the runner pauses, asks the user "continue or
+abort?", and either resets the buffer for that tool (allowing the model
+a fresh chance) or aborts the run.
+
+Threshold is **3** by default — same as OpenCode. Override per-process
+via the ``ARU_DOOM_LOOP_THRESHOLD`` env var (must be ≥ 2; values below
+fall back to the default to avoid pathologically eager prompts).
+
+Args equality uses ``json.dumps(..., sort_keys=True)`` so two calls with
+the same logical args but differing key order — ``{"a": 1, "b": 2}`` vs
+``{"b": 2, "a": 1}`` — are correctly treated as identical. ``default=str``
+keeps non-JSON values (e.g. Path) from raising; the resulting string is
+still a stable signature for equality.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections import deque
+from typing import Any
+
+
+DEFAULT_THRESHOLD = 3
+_ENV_VAR = "ARU_DOOM_LOOP_THRESHOLD"
+
+
+def _stable_signature(tool_name: str, tool_args: Any) -> tuple[str, str]:
+    """Return a hashable equality signature for a tool invocation.
+
+    The args portion is a JSON dump with ``sort_keys=True`` so two calls
+    that differ only by key order in the args dict are treated as equal.
+    Non-JSON values (Paths, datetimes, etc.) are stringified so the dump
+    never raises — the goal is a stable signature, not a round-trippable
+    payload.
+    """
+    if isinstance(tool_args, dict):
+        try:
+            args_repr = json.dumps(tool_args, sort_keys=True, default=str)
+        except Exception:
+            # json.dumps can still fail on truly exotic values (e.g.
+            # circular refs). Fallback to repr — less stable but never
+            # raises, and the detector tolerates occasional mismatches.
+            args_repr = repr(sorted(tool_args.items()))
+    elif tool_args is None:
+        args_repr = "null"
+    else:
+        # Non-dict args (rare — Agno usually wraps in a dict) — just str.
+        args_repr = str(tool_args)
+    return (tool_name or "", args_repr)
+
+
+def threshold_from_env() -> int:
+    """Read ``ARU_DOOM_LOOP_THRESHOLD`` or return the default.
+
+    Values < 2 fall back to the default — a threshold of 1 would fire on
+    the very first call which is meaningless, and a threshold of 0 makes
+    the deque() unbounded. Invalid values (non-int) also fall back.
+    """
+    raw = os.environ.get(_ENV_VAR)
+    if raw is None:
+        return DEFAULT_THRESHOLD
+    try:
+        v = int(raw)
+    except ValueError:
+        return DEFAULT_THRESHOLD
+    if v < 2:
+        return DEFAULT_THRESHOLD
+    return v
+
+
+class DoomLoopDetector:
+    """Sliding-window detector for repeated identical tool calls.
+
+    Each ``record(tool_name, tool_args)`` call appends a signature to the
+    window and returns ``True`` iff the window is now full **and** every
+    entry in it is identical (i.e. the last N calls were the exact same
+    tool with the exact same args).
+
+    The detector is stateless beyond its window — there is no notion of
+    sessions or scopes. The runner instantiates one detector per turn of
+    the primary agent loop; sub-agents that run their own arun loop
+    (delegate.py) get their own detector via the same wiring.
+    """
+
+    def __init__(self, threshold: int | None = None) -> None:
+        self.threshold: int = threshold if threshold is not None else threshold_from_env()
+        self._recent: deque[tuple[str, str]] = deque(maxlen=self.threshold)
+
+    def record(self, tool_name: str, tool_args: Any) -> bool:
+        """Append a call's signature; return True if a doom-loop is now detected."""
+        sig = _stable_signature(tool_name, tool_args)
+        self._recent.append(sig)
+        if len(self._recent) < self.threshold:
+            return False
+        first = self._recent[0]
+        return all(s == first for s in self._recent)
+
+    def reset(self) -> None:
+        """Forget all recorded calls. Used after manual intervention."""
+        self._recent.clear()
+
+    def reset_for_tool(self, tool_name: str) -> None:
+        """Drop every entry whose tool_name equals *tool_name*.
+
+        Called after the user chooses *continue* on a doom-loop prompt:
+        the buffer is wiped for that specific tool so the very next call
+        doesn't immediately re-trigger the same prompt. Other tools'
+        history (which were not part of the loop) is preserved so a
+        secondary loop on a different tool still detects.
+        """
+        kept = [s for s in self._recent if s[0] != tool_name]
+        self._recent = deque(kept, maxlen=self.threshold)
+
+    def __len__(self) -> int:  # convenience for tests
+        return len(self._recent)
+
+
+__all__ = [
+    "DEFAULT_THRESHOLD",
+    "DoomLoopDetector",
+    "threshold_from_env",
+]

{aru_code-0.48.0 → aru_code-0.52.0}/aru/events.py

@@ -103,6 +103,31 @@ class SubagentCompleteEvent(BaseEvent):
     duration_ms: float = 0.0
 
 
+class SubagentToolStartedEvent(BaseEvent):
+    """A tool call started inside a running sub-agent.
+
+    Distinct from ``tool.called`` — that event fires from the orchestrator's
+    own tool loop. ``subagent.tool.started`` fires from inside a delegated
+    sub-agent's stream and carries the parent ``task_id`` so the TUI's
+    SubagentPanel can update the right row.
+    """
+
+    event_type: Literal["subagent.tool.started"] = "subagent.tool.started"
+    task_id: str = ""           # subagent's task_id (the row key)
+    tool_id: str = ""
+    tool_name: str = ""
+    tool_args_preview: str = ""  # first ~80 chars of args for the row label
+
+
+class SubagentToolCompletedEvent(BaseEvent):
+    event_type: Literal["subagent.tool.completed"] = "subagent.tool.completed"
+    task_id: str = ""
+    tool_id: str = ""
+    tool_name: str = ""
+    duration_ms: float = 0.0
+    error: str | None = None
+
+
 # ── Workspace / cwd ───────────────────────────────────────────────────
 
 
@@ -141,6 +166,29 @@ class PermissionModeChangedEvent(BaseEvent):
 # ── Intra-turn metrics ────────────────────────────────────────────────
 
 
+class TasklistUpdatedEvent(BaseEvent):
+    """Published whenever ``create_task_list`` / ``update_task`` mutates
+    the executor's subtask list. Lets the TUI ``TasklistPanel`` render
+    a live sidebar without reading the chat for the Rich panel.
+
+    ``tasks`` is the full list (newest snapshot) — subscribers do not
+    need to maintain incremental state. Empty list = list cleared.
+    """
+
+    event_type: Literal["tasklist.updated"] = "tasklist.updated"
+    tasks: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class PlanUpdatedEvent(BaseEvent):
+    """Published when macro plan steps change (enter_plan_mode /
+    update_plan_step). Same shape contract as TasklistUpdatedEvent —
+    full snapshot, sidebar consumes directly.
+    """
+
+    event_type: Literal["plan.updated"] = "plan.updated"
+    steps: list[dict[str, Any]] = Field(default_factory=list)
+
+
 class MetricsUpdatedEvent(BaseEvent):
     """Published after each internal LLM API call (from ``cache_patch``).
 
@@ -176,11 +224,15 @@ AruEvent = Union[
     ToolCompletedEvent,
     SubagentStartEvent,
     SubagentCompleteEvent,
+    SubagentToolStartedEvent,
+    SubagentToolCompletedEvent,
     CwdChangedEvent,
     FileChangedEvent,
     PermissionDeniedEvent,
     PermissionModeChangedEvent,
     MetricsUpdatedEvent,
+    TasklistUpdatedEvent,
+    PlanUpdatedEvent,
 ]
 
 
@@ -196,11 +248,15 @@ EVENT_MODELS: dict[str, type[BaseEvent]] = {
     "tool.completed": ToolCompletedEvent,
     "subagent.start": SubagentStartEvent,
     "subagent.complete": SubagentCompleteEvent,
+    "subagent.tool.started": SubagentToolStartedEvent,
+    "subagent.tool.completed": SubagentToolCompletedEvent,
     "cwd.changed": CwdChangedEvent,
     "file.changed": FileChangedEvent,
     "permission.denied": PermissionDeniedEvent,
     "permission.mode.changed": PermissionModeChangedEvent,
     "metrics.updated": MetricsUpdatedEvent,
+    "tasklist.updated": TasklistUpdatedEvent,
+    "plan.updated": PlanUpdatedEvent,
 }
 
 

{aru_code-0.48.0 → aru_code-0.52.0}/aru/plugins/hooks.py

@@ -67,6 +67,8 @@ VALID_HOOKS = frozenset({
     # Sub-agent (Tier 2 #3)
     "subagent.start",            # After delegate_task spawns a sub-agent
     "subagent.complete",         # After sub-agent terminates (ok, error, cancelled)
+    "subagent.tool.started",     # Inside a sub-agent: a tool call started
+    "subagent.tool.completed",   # Inside a sub-agent: a tool call completed
 
     # Turn lifecycle (Tier 2 #3)
     "turn.start",                # Beginning of runner.prompt for a new user turn
@@ -76,6 +78,10 @@ VALID_HOOKS = frozenset({
     "metrics.updated",           # After every internal LLM API call (cache_patch);
                                  # lets the TUI refresh tokens/cost mid-turn so long
                                  # implementation runs don't sit silent for minutes.
+
+    # Tasklist / plan visibility (Tier 2 #6 sidebar)
+    "tasklist.updated",          # create_task_list / update_task — full snapshot
+    "plan.updated",              # enter_plan_mode / update_plan_step — full snapshot
 })
 
 

{aru_code-0.48.0 → aru_code-0.52.0}/aru/streaming.py

@@ -174,6 +174,7 @@ async def run_stream(
     )
     from aru.cache_patch import get_last_stop_reason, reset_last_stop_reason
     from aru.display import _format_tool_label
+    from aru.doom_loop import DoomLoopDetector
 
     state = StreamState()
     accumulated = ""
@@ -188,6 +189,14 @@ async def run_stream(
 
     # Track tool start times so the sink gets a duration on completion.
     tool_start_times: dict[str, float] = {}
+    # Cache args at started so the doom-loop detector and any other
+    # post-hoc check can read them at completed without depending on the
+    # provider always populating ``tool_args`` on the completed event.
+    tool_args_by_id: dict[str, Any] = {}
+    # Per-turn doom-loop detector — reset on each new run_stream call so
+    # repeating the same tool across separate user turns isn't a "loop".
+    # See ``aru/doom_loop.py`` for the heuristic.
+    doom_loop_detector = DoomLoopDetector()
     import time as _time
 
     while True:
@@ -229,6 +238,9 @@ async def run_stream(
                 pending_tool_uses[tool_id] = assistant_blocks[-1]
 
                 tool_start_times[tool_id] = _time.monotonic()
+                tool_args_by_id[tool_id] = (
+                    tool_args if isinstance(tool_args, dict) else None
+                )
                 sink.on_tool_started(
                     tool_id=tool_id,
                     tool_name=tool_name,
@@ -303,6 +315,35 @@ async def run_stream(
                     label=tool_name,  # sink caches its own label if needed
                 )
 
+                # Doom-loop check — if the model just made the same call
+                # for the Nth time in a row, pause and ask the user. The
+                # detector is per-turn (constructed at run_stream entry)
+                # so a legitimate repeat across separate turns doesn't
+                # fire. See ``aru/doom_loop.py``.
+                tool_args_for_detector = tool_args_by_id.pop(tool_id, None)
+                if doom_loop_detector.record(tool_name, tool_args_for_detector):
+                    if await _handle_doom_loop(
+                        sink=sink,
+                        tool_name=tool_name,
+                        tool_args=tool_args_for_detector,
+                    ):
+                        # User chose continue — wipe history for this
+                        # tool so the very next call doesn't immediately
+                        # re-prompt. Other tools' history is preserved.
+                        doom_loop_detector.reset_for_tool(tool_name)
+                    else:
+                        # User chose abort. Mark stalled, propagate the
+                        # abort signal to any in-flight sub-agents, and
+                        # break out of the stream — the outer recovery
+                        # loop's stop-reason check will then exit.
+                        state.stalled = True
+                        try:
+                            from aru.runtime import abort_current
+                            abort_current()
+                        except Exception:
+                            pass
+                        break
+
                 # When the last active tool in the round completed, close it
                 # and let the sink flush deferred renders (plan panel etc.).
                 if not pending_tool_uses:
@@ -352,3 +393,64 @@ async def run_stream(
     state.accumulated = accumulated
     sink.on_stream_finished(final_content=accumulated)
     return state
+
+
+async def _handle_doom_loop(
+    *,
+    sink: StreamSink,
+    tool_name: str,
+    tool_args: Any,
+) -> bool:
+    """Notify + prompt the user when a doom-loop fires. Returns True to continue.
+
+    Routed through ``ctx.ui.confirm`` so REPL gets the prompt_toolkit
+    yes/no and TUI gets a ``ConfirmModal`` — same code path as the
+    permission prompts. Wrapped in ``asyncio.to_thread`` because the UI
+    adapter is sync (it bridges to the Textual event loop internally via
+    ``call_from_thread`` and a ``threading.Event``); calling it directly
+    from the async loop would deadlock the TUI.
+    """
+    import asyncio
+    import json
+
+    try:
+        args_preview = json.dumps(
+            tool_args if isinstance(tool_args, dict) else {},
+            sort_keys=True, default=str,
+        )
+    except Exception:
+        args_preview = repr(tool_args)
+    if len(args_preview) > 120:
+        args_preview = args_preview[:117] + "..."
+
+    sink.notify(
+        f"Doom-loop detected: 3× identical {tool_name}({args_preview}). "
+        f"Pausing for user confirmation.",
+        style="bold yellow",
+    )
+
+    prompt = (
+        f"`{tool_name}` was called 3 times in a row with the same input "
+        f"({args_preview}). The agent may be stuck in a loop. Continue?"
+    )
+
+    try:
+        from aru.runtime import get_ctx
+        ctx = get_ctx()
+    except LookupError:
+        # No runtime ctx (test harness without init_ctx) — default to
+        # abort so the loop doesn't keep firing forever.
+        return False
+
+    ui = getattr(ctx, "ui", None)
+    if ui is None:
+        # No UI installed — same conservative default. abort.
+        return False
+
+    try:
+        return bool(await asyncio.to_thread(ui.confirm, prompt, False))
+    except Exception:
+        # If the prompt itself raises (timeout, missing app, etc.) we
+        # default to abort — the model is stuck and we can't ask the
+        # user, so continuing risks burning more budget for nothing.
+        return False

{aru_code-0.48.0 → aru_code-0.52.0}/aru/tools/delegate.py

@@ -421,11 +421,23 @@ Do not create documentation files unless explicitly asked.
                 "task": (task or "")[:500],
             })
 
+            from aru.runtime import _schedule_publish as _sched_t
             try:
                 async for event in agent_instance.arun(task, stream=True, stream_events=True, yield_run_output=True):
                     if is_aborted():
                         _trace.status = "cancelled"
                         _trace.ended_at = _time.monotonic()
+                        # Emit subagent.complete with status=cancelled so the
+                        # TUI's SubagentPanel can mark + reap the row instead
+                        # of leaving it stuck in "running". Mirrors the
+                        # complete path below.
+                        _sched_t("subagent.complete", {
+                            "task_id": _trace.task_id,
+                            "status": "cancelled",
+                            "duration": (_trace.ended_at or 0) - (_trace.started_at or 0),
+                            "tokens_in": _trace.tokens_in,
+                            "tokens_out": _trace.tokens_out,
+                        })
                         return f"[{label} | task_id={task_id_for_output}] Cancelled by user."
                     if isinstance(event, RunOutput):
                         run_output = event
@@ -433,9 +445,23 @@ Do not create documentation files unless explicitly asked.
                     elif isinstance(event, ToolCallStartedEvent):
                         if hasattr(event, "tool") and event.tool:
                             t_id = getattr(event.tool, "tool_call_id", None) or (event.tool.tool_name or "tool")
+                            t_name_start = event.tool.tool_name or "tool"
+                            t_args_start = getattr(event.tool, "tool_args", None)
                         else:
                             t_id = getattr(event, "tool_call_id", None) or getattr(event, "tool_name", "tool")
+                            t_name_start = getattr(event, "tool_name", "tool")
+                            t_args_start = getattr(event, "tool_args", None)
                         _tool_starts[t_id] = _time.monotonic()
+                        # Live TUI: tell the SubagentPanel which subagent is
+                        # currently running which tool, so a fan-out of N
+                        # delegates renders as N rows each showing its own
+                        # in-flight tool instead of opaque "running…".
+                        _sched_t("subagent.tool.started", {
+                            "task_id": _trace.task_id,
+                            "tool_id": str(t_id),
+                            "tool_name": t_name_start,
+                            "tool_args_preview": (str(t_args_start) if t_args_start else "")[:80],
+                        })
                     elif isinstance(event, ToolCallCompletedEvent):
                         if hasattr(event, "tool") and event.tool:
                             t_id = getattr(event.tool, "tool_call_id", None) or getattr(event.tool, "tool_name", "tool")
@@ -452,12 +478,29 @@ Do not create documentation files unless explicitly asked.
                             "args_preview": (str(t_args) if t_args else "")[:150],
                             "duration": round(dur, 3),
                         })
+                        _sched_t("subagent.tool.completed", {
+                            "task_id": _trace.task_id,
+                            "tool_id": str(t_id),
+                            "tool_name": t_name,
+                            "duration_ms": round(dur * 1000, 1),
+                            "error": None,
+                        })
                     elif isinstance(event, RunContentEvent):
                         if hasattr(event, "content") and event.content:
                             result_content += event.content
             except Exception:
                 _trace.status = "error"
                 _trace.ended_at = _time.monotonic()
+                # Same rationale as cancel: surface a complete event with
+                # status=error so the panel can stop the row instead of
+                # leaving it spinning forever.
+                _sched_t("subagent.complete", {
+                    "task_id": _trace.task_id,
+                    "status": "error",
+                    "duration": (_trace.ended_at or 0) - (_trace.started_at or 0),
+                    "tokens_in": _trace.tokens_in,
+                    "tokens_out": _trace.tokens_out,
+                })
                 raise
 
             if run_output and hasattr(run_output, "metrics") and run_output.metrics:

{aru_code-0.48.0 → aru_code-0.52.0}/aru/tools/tasklist.py

@@ -59,6 +59,11 @@ def _show(panel: Panel) -> None:
     so we route the panel into the ChatPane via ``call_from_thread``
     instead (matches how TextualBusSink hands rich renderables off to
     the app loop).
+
+    The TUI sidebar (``TasklistPanel``) listens to ``tasklist.updated``
+    / ``plan.updated`` events directly — it does not use this path. The
+    REPL still gets the panel printed; the TUI also still prints it
+    inline as a fallback when the user has the sidebar hidden.
     """
     ctx = get_ctx()
     if ctx.display and hasattr(ctx.display, "show_permission"):
@@ -69,25 +74,106 @@ def _show(panel: Panel) -> None:
         return
     tui_app = getattr(ctx, "tui_app", None)
     if tui_app is not None:
+        # Sidebar consumes events; we only print into chat when the
+        # sidebar is hidden (Ctrl+B toggle) so the user still has
+        # somewhere to see the panel.
         try:
-            from aru.tui.widgets.chat import ChatPane
-            chat = tui_app.query_one(ChatPane)
-            # Scrollable=True so a big panel (diff preview / task list /
-            # plan steps) stays contained — the user can scroll inside
-            # it without losing the chat stream above/below.
-            kwargs = {"scrollable": True}
+            from aru.tui.widgets.tasklist_panel import TasklistPanel
+            sidebar = None
             try:
-                tui_app.call_from_thread(
-                    chat.add_renderable, panel, **kwargs
-                )
+                sidebar = tui_app.query_one(TasklistPanel)
             except Exception:
-                chat.add_renderable(panel, **kwargs)
+                pass
+            if sidebar is not None and sidebar.has_class("-hidden"):
+                from aru.tui.widgets.chat import ChatPane
+                chat = tui_app.query_one(ChatPane)
+                kwargs = {"scrollable": True}
+                try:
+                    tui_app.call_from_thread(
+                        chat.add_renderable, panel, **kwargs
+                    )
+                except Exception:
+                    chat.add_renderable(panel, **kwargs)
+            # When the sidebar is visible, the event-driven render is
+            # the canonical view; chat stays clean.
             return
         except Exception:
             pass
     ctx.console.print(panel)
 
 
+def _publish_tasklist(tasks: list[dict]) -> None:
+    """Best-effort publish of ``tasklist.updated`` to the plugin bus."""
+    try:
+        ctx = get_ctx()
+        mgr = getattr(ctx, "plugin_manager", None)
+        if mgr is None:
+            return
+        payload = {"tasks": [dict(t) for t in tasks]}
+        # Plugin manager.publish is async; spawn as a task so call sites
+        # that are themselves sync (tools run in threads) don't block.
+        try:
+            import asyncio
+            loop = asyncio.get_running_loop()
+            loop.create_task(mgr.publish("tasklist.updated", payload))
+        except RuntimeError:
+            # No running loop in this thread — fall back to scheduling
+            # on the App's loop if we can reach it.
+            tui_app = getattr(ctx, "tui_app", None)
+            if tui_app is not None:
+                try:
+                    tui_app.call_from_thread(
+                        _schedule_publish, mgr, "tasklist.updated", payload
+                    )
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+
+def _publish_plan(steps: list) -> None:
+    """Best-effort publish of ``plan.updated`` with the current plan."""
+    try:
+        ctx = get_ctx()
+        mgr = getattr(ctx, "plugin_manager", None)
+        if mgr is None:
+            return
+        payload = {
+            "steps": [
+                {
+                    "index": getattr(s, "index", 0),
+                    "description": getattr(s, "description", ""),
+                    "status": getattr(s, "status", "pending"),
+                }
+                for s in steps
+            ]
+        }
+        try:
+            import asyncio
+            loop = asyncio.get_running_loop()
+            loop.create_task(mgr.publish("plan.updated", payload))
+        except RuntimeError:
+            tui_app = getattr(ctx, "tui_app", None)
+            if tui_app is not None:
+                try:
+                    tui_app.call_from_thread(
+                        _schedule_publish, mgr, "plan.updated", payload
+                    )
+                except Exception:
+                    pass
+    except Exception:
+        pass
+
+
+def _schedule_publish(mgr, event_type: str, payload: dict) -> None:
+    """Helper run via call_from_thread to schedule an async publish."""
+    try:
+        import asyncio
+        asyncio.create_task(mgr.publish(event_type, payload))
+    except Exception:
+        pass
+
+
 def create_task_list(tasks: list[str]) -> str:
     """Set (or replace) the subtask list for the current phase.
 
@@ -115,6 +201,7 @@ def create_task_list(tasks: list[str]) -> str:
     created = store.create(tasks)
     panel = _render_task_list(created)
     _show(panel)
+    _publish_tasklist(created)
 
     task_lines = "\n".join(f"  {t['index']}. {t['description']}" for t in created)
     verb = "replaced" if was_replaced else "created"
@@ -143,6 +230,7 @@ def update_task(index: int, status: str) -> str:
     all_tasks = store.get_all()
     panel = _render_task_list(all_tasks)
     _show(panel)
+    _publish_tasklist(all_tasks)
 
     # Check if all done
     completed_count = sum(1 for t in all_tasks if t["status"] == "completed")
@@ -177,6 +265,7 @@ def flush_plan_render(session) -> None:
     if not steps:
         return
     _show(_render_plan_steps(steps))
+    _publish_plan(steps)
 
 
 def _render_plan_steps(steps: list) -> Panel: