flowjet 2.0.2__tar.gz → 2.0.4__tar.gz

{flowjet-2.0.2 → flowjet-2.0.4}/CHANGELOG.md

@@ -10,6 +10,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.4] — 2026-09-19
+
+### Changed
+
+- Bumped `soothe` lower bound to `1.0.13` (was `1.0.12`). soothe-nano stays
+  pinned at `>=1.2.28,<1.3.0`.
+
+## [2.0.3] — 2026-09-18
+
+### Added
+
+- **Plan-step and middleware-phase progress in the CLI.** The nano bridge now
+  maps the host (soothe) loop's todo list and middleware phase updates into
+  step/tool progress events, so the terminal shows `Step 2/3 · Create a2.txt`
+  instead of a bare `Working` line. Late-parsing tool args refresh the status
+  line once, and `write_todos` bookkeeping is suppressed as a tool call (it
+  already drives the step line).
+
 ## [2.0.2] — 2026-09-18
 
 ### Added

{flowjet-2.0.2 → flowjet-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowjet
-Version: 2.0.2
+Version: 2.0.4
 Summary: FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano
 Project-URL: Homepage, https://github.com/caesar0301/flowjet
 Project-URL: Repository, https://github.com/caesar0301/flowjet
@@ -23,7 +23,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.11
 Requires-Dist: soothe-nano<1.3.0,>=1.2.28
-Requires-Dist: soothe<2.0.0,>=1.0.12
+Requires-Dist: soothe<2.0.0,>=1.0.13
 Provides-Extra: dev
 Requires-Dist: httpx>=0.27.0; extra == 'dev'
 Requires-Dist: mypy>=1.0.0; extra == 'dev'

{flowjet-2.0.2 → flowjet-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flowjet"
-version = "2.0.2"
+version = "2.0.4"
 description = "FlowJet — agent CLI (fj) and server (ACP + OpenAI-compatible HTTP) powered by soothe-nano"
 readme = "README.md"
 license = { text = "MIT" }
@@ -31,7 +31,7 @@ classifiers = [
 dependencies = [
     # Default CLI runtime (FLOWJET_BACKEND=soothe). soothe is a host layer over
     # soothe-nano, so nano stays pinned explicitly: soothe only caps it at <2.
-    "soothe>=1.0.12,<2.0.0",
+    "soothe>=1.0.13,<2.0.0",
     "soothe-nano>=1.2.28,<1.3.0",
 ]
 

{flowjet-2.0.2 → flowjet-2.0.4}/src/flowjet/cli/agent.py

@@ -8,14 +8,12 @@ Nano bootstrap, config loading and the builtin-skill root now live in
 from __future__ import annotations
 
 import logging
-import os
-import sys
-from logging.handlers import RotatingFileHandler
 from pathlib import Path
 from typing import Any
 
 from soothe_nano.config import SootheConfig
 
+from flowjet.cli.cli import _CompactConsoleFormatter
 from flowjet.core.bootstrap import (
     BUILTIN_SKILLS_DIR,
     FJ_CORE_SKILL_NAMES,
@@ -31,6 +29,27 @@ from flowjet.core.modes import CLI_PROFILE, apply_profile
 
 logger = logging.getLogger(__name__)
 
+# ---------------------------------------------------------------------------
+# CLI logging (delegated to ``flowjet.cli.cli`` at call time)
+# ---------------------------------------------------------------------------
+
+
+def configure_cli_logging(*, verbose: bool = False) -> None:
+    """Quiet the console for one-shot CLI use (see ``flowjet.cli.cli``).
+
+    Delegated dynamically so monkeypatching ``flowjet.cli.cli.configure_cli_logging``
+    (as tests do via ``monkeypatch.setattr(cli, ...)``) is honored here too.
+    """
+    from flowjet.cli import cli as _cli
+
+    _cli.configure_cli_logging(verbose=verbose)
+
+
+def silence_after_plugins(*, verbose: bool = False) -> None:
+    """Re-apply quieting after plugin imports (belt-and-suspenders)."""
+    configure_cli_logging(verbose=verbose)
+
+
 # ---------------------------------------------------------------------------
 # Builtin skills (re-exported; owned by flowjet.core.bootstrap)
 # ---------------------------------------------------------------------------
@@ -57,73 +76,6 @@ def apply_fj_defaults(config: SootheConfig) -> SootheConfig:
     return apply_profile(config, CLI_PROFILE)
 
 
-# ---------------------------------------------------------------------------
-# CLI logging
-# ---------------------------------------------------------------------------
-
-_BROWSER_USE_SETUP_LOGGING = "BROWSER_USE_SETUP_LOGGING"
-_FJ_CONSOLE_HANDLER = "fj-console"
-
-
-class _CompactConsoleFormatter(logging.Formatter):
-    """One-line console records without exception tracebacks."""
-
-    def formatException(self, ei: object) -> str:  # noqa: N802 - logging API
-        return ""
-
-    def format(self, record: logging.LogRecord) -> str:
-        # logger.exception sets exc_info; drop it so format() stays one line.
-        record.exc_info = None
-        record.exc_text = None
-        return super().format(record)
-
-
-def configure_cli_logging(*, verbose: bool = False) -> None:
-    """Quiet the console for one-shot CLI use.
-
-    - Opt out of ``browser_use`` import-time root logger setup when unset.
-    - Remove existing root stream handlers (stderr/stdout) so init INFO
-      lines do not interleave with the agent answer.
-    - Prevent ``lastResort`` traceback dumps from soothe tool failures.
-    - When ``verbose``, show WARNING+ as single-line messages on stderr.
-    """
-    os.environ.setdefault(_BROWSER_USE_SETUP_LOGGING, "false")
-    _remove_root_console_handlers()
-    root = logging.getLogger()
-    if verbose:
-        handler = logging.StreamHandler(sys.stderr)
-        handler.set_name(_FJ_CONSOLE_HANDLER)
-        handler.setLevel(logging.WARNING)
-        handler.setFormatter(_CompactConsoleFormatter("%(message)s"))
-        root.addHandler(handler)
-    elif not root.handlers:
-        null = logging.NullHandler()
-        null.set_name(_FJ_CONSOLE_HANDLER)
-        root.addHandler(null)
-    if root.level < logging.WARNING:
-        root.setLevel(logging.WARNING)
-
-
-def silence_after_plugins(*, verbose: bool = False) -> None:
-    """Re-apply quieting after plugin imports (belt-and-suspenders)."""
-    configure_cli_logging(verbose=verbose)
-
-
-def _remove_root_console_handlers() -> None:
-    root = logging.getLogger()
-    for handler in list(root.handlers):
-        if isinstance(handler, RotatingFileHandler):
-            continue
-        if isinstance(handler, logging.FileHandler):
-            continue
-        if isinstance(handler, logging.StreamHandler) or isinstance(handler, logging.NullHandler):
-            root.removeHandler(handler)
-            try:
-                handler.close()
-            except Exception:  # pragma: no cover - defensive
-                pass
-
-
 # ---------------------------------------------------------------------------
 # Agent build
 # ---------------------------------------------------------------------------
@@ -165,6 +117,7 @@ async def build_agent(
 __all__ = [
     "BUILTIN_SKILLS_DIR",
     "FJ_CORE_SKILL_NAMES",
+    "_CompactConsoleFormatter",
     "apply_fj_defaults",
     "build_agent",
     "configure_cli_logging",

{flowjet-2.0.2 → flowjet-2.0.4}/src/flowjet/cli/cli.py

@@ -8,18 +8,113 @@ from __future__ import annotations
 import argparse
 import asyncio
 import contextlib
+import logging
+import os
 import sys
 from collections.abc import Coroutine
+from logging.handlers import RotatingFileHandler
 from pathlib import Path
 from typing import Any
 
 from flowjet.cli import __version__
-from flowjet.cli.agent import configure_cli_logging
 
 FORMAL_CLI = "flowjet"
 CLI_ALIASES = frozenset({"fj", "fjf", FORMAL_CLI})
 
 
+# ---------------------------------------------------------------------------
+# CLI logging — stdlib only, kept here so ``fj -V`` / ``fj -h`` never pay the
+# heavy ``soothe_nano`` / ``flowjet.core.bootstrap`` import cost.
+# ---------------------------------------------------------------------------
+
+_BROWSER_USE_SETUP_LOGGING = "BROWSER_USE_SETUP_LOGGING"
+_FJ_CONSOLE_HANDLER = "fj-console"
+
+
+class _CompactConsoleFormatter(logging.Formatter):
+    """One-line console records without exception tracebacks."""
+
+    def formatException(self, ei: object) -> str:  # noqa: N802 - logging API
+        return ""
+
+    def format(self, record: logging.LogRecord) -> str:
+        # logger.exception sets exc_info; drop it so format() stays one line.
+        record.exc_info = None
+        record.exc_text = None
+        return super().format(record)
+
+
+_FILE_LOGGING_INSTALLED = False
+
+
+def configure_cli_logging(*, verbose: bool = False) -> None:
+    """Quiet the console for one-shot CLI use and enable file logging by default.
+
+    - Opt out of ``browser_use`` import-time root logger setup when unset.
+    - Remove existing root stream handlers (stderr/stdout) so init INFO
+      lines do not interleave with the agent answer.
+    - Prevent ``lastResort`` traceback dumps from soothe tool failures.
+    - When ``verbose``, show WARNING+ as single-line messages on stderr.
+    - Attach a rotating file handler at ``<FLOWJET_HOME>/logs/cli.log`` so
+      every CLI run is recorded by default (idempotent across re-invocations
+      within the same process, e.g. tests).
+    """
+    os.environ.setdefault(_BROWSER_USE_SETUP_LOGGING, "false")
+    _remove_root_console_handlers()
+    root = logging.getLogger()
+    if verbose:
+        handler = logging.StreamHandler(sys.stderr)
+        handler.set_name(_FJ_CONSOLE_HANDLER)
+        handler.setLevel(logging.WARNING)
+        handler.setFormatter(_CompactConsoleFormatter("%(message)s"))
+        root.addHandler(handler)
+    elif not root.handlers:
+        null = logging.NullHandler()
+        null.set_name(_FJ_CONSOLE_HANDLER)
+        root.addHandler(null)
+    if root.level < logging.WARNING:
+        root.setLevel(logging.WARNING)
+
+    _ensure_cli_file_logging()
+
+
+def _ensure_cli_file_logging() -> None:
+    """Attach the rotating file handler for CLI runs (idempotent)."""
+    global _FILE_LOGGING_INSTALLED
+    if _FILE_LOGGING_INSTALLED:
+        return
+    try:
+        from flowjet.core.home import cli_log_path, ensure_flowjet_home
+
+        ensure_flowjet_home()
+        from soothe_nano.logging.setup import setup_logging
+
+        setup_logging(log_file=str(cli_log_path()), extra_logger_names=("flowjet",))
+        _FILE_LOGGING_INSTALLED = True
+    except Exception:  # pragma: no cover - logging must never break the CLI
+        pass
+
+
+def silence_after_plugins(*, verbose: bool = False) -> None:
+    """Re-apply quieting after plugin imports (belt-and-suspenders)."""
+    configure_cli_logging(verbose=verbose)
+
+
+def _remove_root_console_handlers() -> None:
+    root = logging.getLogger()
+    for handler in list(root.handlers):
+        if isinstance(handler, RotatingFileHandler):
+            continue
+        if isinstance(handler, logging.FileHandler):
+            continue
+        if isinstance(handler, logging.StreamHandler) or isinstance(handler, logging.NullHandler):
+            root.removeHandler(handler)
+            try:
+                handler.close()
+            except Exception:  # pragma: no cover - defensive
+                pass
+
+
 def resolve_cli_prog(argv0: str | None = None) -> str:
     """Return the invoked command name for help / version strings.
 
@@ -217,6 +312,13 @@ class _HelpFormatter(argparse.RawDescriptionHelpFormatter):
     def __init__(self, prog: str) -> None:
         super().__init__(prog, max_help_position=26, width=92)
 
+    def _format_action(self, action: argparse.Action) -> str:  # type: ignore[override]
+        # Resolve lazy help strings only when help is actually rendered, so
+        # ``-V`` never pays for the import behind ``_default_config_help``.
+        if isinstance(action.help, _LazyHelp):
+            action.help = str(action.help)
+        return super()._format_action(action)
+
 
 def _default_config_help() -> str:
     from flowjet.cli.agent import default_config_path
@@ -224,6 +326,26 @@ def _default_config_help() -> str:
     return f"Alternate nano.yml (default: {default_config_path()})"
 
 
+class _LazyHelp:
+    """Resolve a help-string callable only when argparse reads it.
+
+    ``-V`` / ``-h``-without-our-flag paths never touch the help text, so the
+    heavy import behind ``_default_config_help`` stays deferred until a flag
+    that actually shows help (``-h``) or errors is invoked.
+    """
+
+    __slots__ = ("_factory", "_cached")
+
+    def __init__(self, factory: Any) -> None:
+        self._factory = factory
+        self._cached: str | None = None
+
+    def __str__(self) -> str:
+        if self._cached is None:
+            self._cached = self._factory()
+        return self._cached
+
+
 def _build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     cli_prog = prog or resolve_cli_prog()
     parser = argparse.ArgumentParser(
@@ -297,7 +419,7 @@ def _build_parser(prog: str | None = None) -> argparse.ArgumentParser:
         "-c",
         "--config",
         metavar="PATH",
-        help=_default_config_help(),
+        help=_LazyHelp(_default_config_help),
     )
     paths.add_argument(
         "-w",
@@ -324,7 +446,7 @@ def _build_setup_parser(prog: str | None = None) -> argparse.ArgumentParser:
         "-c",
         "--config",
         metavar="PATH",
-        help=_default_config_help(),
+        help=_LazyHelp(_default_config_help),
     )
     return parser
 
@@ -565,8 +687,17 @@ def main_follow(argv: list[str] | None = None) -> int:
 
 def main(argv: list[str] | None = None) -> int:
     try:
-        configure_cli_logging()
+        # Align SOOTHE_HOME with FLOWJET_HOME before any soothe import so
+        # config, data, and logs all land under ~/.flowjet. Must run first:
+        # soothe_sdk.paths binds SOOTHE_HOME at import time.
+        from flowjet.core.home import ensure_flowjet_home
+
+        ensure_flowjet_home()
+        # Parse first so ``-V`` / ``-h`` / ``--help`` exit before we touch the
+        # logging stack (and the heavy ``flowjet.cli.agent`` import it used to
+        # drag in). Version/help must stay instant.
         args = parse_args(argv)
+        configure_cli_logging()
         # Re-apply after parse so ``-v`` can enable compact console warnings.
         if getattr(args, "verbose", False):
             configure_cli_logging(verbose=True)

{flowjet-2.0.2 → flowjet-2.0.4}/src/flowjet/cli/progress.py

@@ -67,6 +67,14 @@ _ACTION_LABELS: dict[str, str] = {
     "queued": "Queued",
 }
 
+# Host (soothe) loop phases surfaced as graph updates by the nano bridge.
+_STEP_PHASE_LABELS: dict[str, str] = {
+    "planned": "Planning steps",
+    "decomposed": "Decomposing task",
+    "evaluated": "Evaluating step",
+    "fanned_out": "Coordinating agents",
+}
+
 # Verb + color for well-known tools (fallback: Running / yellow)
 _TOOL_VERBS: dict[str, tuple[str, str]] = {
     "read_file": ("Reading", "yellow"),
@@ -693,6 +701,32 @@ def friendly_progress(data: dict[str, Any]) -> tuple[str, str] | None:
                 label = f"{label} · {detail}"
         return _fit(label), color
 
+    if domain == "step":
+        # Plan steps come from the agent's todo list (one event per change).
+        if "steps" in data or "todo" in data:
+            step = data.get("step")
+            steps = data.get("steps")
+            todo = _compact(data.get("todo"))
+            head = f"Step {step}/{steps}" if step and steps else "Step"
+            if todo:
+                return _fit(f"{head} · {todo}"), "blue"
+            if data.get("status") == "completed":
+                return _fit(f"Steps complete · {step}/{steps}"), "green"
+            return _fit(head), "blue"
+        label = _STEP_PHASE_LABELS.get(action) or verb
+        return _fit(label), "blue"
+
+    if event_type == "soothe.ask.requested":
+        question = _compact(data.get("question") or data.get("message"))
+        if question:
+            q_limit = _detail_budget(prefix="Preparing question · ", fraction=0.55, floor=16)
+            return _fit(f"Preparing question · {_truncate_middle(question, q_limit)}"), "magenta"
+        return _fit("Preparing question"), "magenta"
+
+    if event_type == "soothe.intake.routed":
+        name = _compact(data.get("subagent") or data.get("subagent_type") or "specialist")
+        return _fit(f"Routing · {name}"), "magenta"
+
     if domain == "skill" or "skill" in short:
         color = "blue"
         name = data.get("skill") or data.get("name") or "skill"

{flowjet-2.0.2 → flowjet-2.0.4}/src/flowjet/core/bridges/nano/mapping.py

@@ -33,6 +33,161 @@ _SKIP_CUSTOM_TYPES = frozenset(
     }
 )
 
+# Host (soothe) middleware surfaces as ``<Middleware>.<phase>`` graph updates.
+# The CLI renders these through ``friendly_progress``, so the synthetic payloads
+# below stay in the same ``soothe.*`` vocabulary as nano's custom events.
+_HOST_PHASE_EVENTS: dict[str, str] = {
+    "GoalStepGuardMiddleware": "soothe.step.planned",
+    "DecomposeTaskMiddleware": "soothe.step.decomposed",
+    "EvalStepMiddleware": "soothe.step.evaluated",
+    "WestWorldMiddleware": "soothe.step.fanned_out",
+    "AskUserPromptMiddleware": "soothe.ask.requested",
+    "IntakeOnlyTaskGuardMiddleware": "soothe.intake.routed",
+}
+
+# Plan bookkeeping: the todo list already drives the step line.
+_QUIET_TOOLS = frozenset({"write_todos", "todo_write", "write_todo_list"})
+
+# Fires on every turn with no user-visible content.
+_SKIP_UPDATE_NODES = frozenset(
+    {
+        "PatchToolCallsMiddleware",
+        "ProgressiveToolMiddleware",
+        "WorkspaceContextMiddleware",
+        "TodoListMiddleware",
+        "model",
+        "tools",
+    }
+)
+
+
+def todo_step_payload(todos: list[Any]) -> dict[str, Any] | None:
+    """Turn a soothe todo list into a step-progress payload.
+
+    The agent writes its plan as todos (``write_todos``); each ``in_progress``
+    item is the step the user is waiting on, which is far more informative than
+    a generic "Working" line.
+    """
+    items = [item for item in todos if isinstance(item, dict)]
+    if not items:
+        return None
+    total = len(items)
+    done = sum(1 for item in items if str(item.get("status")) == "completed")
+    current = next(
+        (item for item in items if str(item.get("status")) == "in_progress"),
+        None,
+    )
+    if current is None:
+        if done == 0:
+            return None
+        return {
+            "type": "soothe.step.progress",
+            "step": done,
+            "steps": total,
+            "done": done,
+            "status": "completed",
+            "todo": "",
+        }
+    return {
+        "type": "soothe.step.progress",
+        "step": items.index(current) + 1,
+        "steps": total,
+        "done": done,
+        "status": "in_progress",
+        "todo": str(current.get("content") or ""),
+    }
+
+
+def _skill_names(payload: dict[str, Any]) -> list[str]:
+    """Best-effort skill names from a ``SkillActivationMiddleware`` payload."""
+    raw = payload.get("skill_activation")
+    if isinstance(raw, dict):
+        raw = raw.get("skills") or raw.get("activated") or raw.get("names") or []
+    if not isinstance(raw, (list, tuple)):
+        return []
+    names: list[str] = []
+    for item in raw:
+        if isinstance(item, str) and item.strip():
+            names.append(item.strip())
+        elif isinstance(item, dict):
+            name = item.get("name") or item.get("skill")
+            if isinstance(name, str) and name.strip():
+                names.append(name.strip())
+    return names
+
+
+def update_progress(data: dict[str, Any]) -> tuple[str, dict[str, Any]] | None:
+    """Map one soothe ``updates`` chunk to ``(dedupe_key, event_payload)``.
+
+    Returns ``None`` for the plumbing updates that carry no user-visible step.
+    """
+    todos = data.get("todos")
+    if isinstance(todos, list):
+        payload = todo_step_payload(todos)
+        if payload is not None:
+            key = f"todo:{payload['step']}/{payload['steps']}:{payload['todo']}:{payload['done']}"
+            return key, payload
+
+    for node, node_payload in data.items():
+        name = node.split(".")[0]
+        # The todo list rides along inside the ``tools`` node update.
+        if isinstance(node_payload, dict) and isinstance(node_payload.get("todos"), list):
+            payload = todo_step_payload(node_payload["todos"])
+            if payload is not None:
+                key = (
+                    f"todo:{payload['step']}/{payload['steps']}:{payload['todo']}:{payload['done']}"
+                )
+                return key, payload
+        if name in _SKIP_UPDATE_NODES:
+            continue
+        event = _HOST_PHASE_EVENTS.get(name)
+        if event is not None:
+            phase = node.split(".", 1)[1] if "." in node else ""
+            return node, {"type": event, "middleware": name, "phase": phase}
+        if name == "SkillActivationMiddleware" and isinstance(node_payload, dict):
+            names = _skill_names(node_payload)
+            if names:
+                return node, {"type": "soothe.skill.activated", "skill": ", ".join(names)}
+    return None
+
+
+# Arg keys worth echoing in a one-line tool summary (first match wins).
+_TOOL_SUMMARY_KEYS = (
+    "file_path",
+    "path",
+    "target_file",
+    "command",
+    "cmd",
+    "script",
+    "query",
+    "pattern",
+    "url",
+    "skill",
+)
+
+
+def tool_call_summary(name: str, args: dict[str, Any]) -> str:
+    """``write_file a.txt``-style summary for renderers without tool metadata."""
+    for key in _TOOL_SUMMARY_KEYS:
+        value = args.get(key)
+        if isinstance(value, (str, int, float)) and str(value).strip():
+            text = " ".join(str(value).split())
+            return f"{name} {text[:60]}"
+    return str(name)
+
+
+def step_message(payload: dict[str, Any]) -> str:
+    """Human-readable one-liner for a step payload (used by non-CLI renderers)."""
+    step = payload.get("step")
+    steps = payload.get("steps")
+    todo = str(payload.get("todo") or "").strip()
+    head = f"{step}/{steps}" if step and steps else "step"
+    if todo:
+        return f"Step {head} · {todo}"
+    if payload.get("status") == "completed":
+        return f"Steps complete · {head}"
+    return f"Step {head}"
+
 
 def resolve_interaction_mode(metadata: dict[str, Any] | None) -> str:
     """Return ``agent`` or ``ask`` from request metadata (default ``agent``)."""
@@ -114,6 +269,8 @@ async def iter_nano_runtime_events(
     open_args: dict[str, dict[str, Any]] = {}
     tool_args = ToolCallArgAccumulator()
     emitted_calls: set[str] = set()
+    refreshed_calls: set[str] = set()
+    last_step_key = ""
 
     try:
         async for chunk in agent.astream(
@@ -132,8 +289,23 @@ async def iter_nano_runtime_events(
                     yield mapped
                 continue
 
-            if mode == "updates" and isinstance(data, dict) and "__interrupt__" in data:
-                yield InterruptWaiting(message="Waiting for input…")
+            if mode == "updates" and isinstance(data, dict):
+                if "__interrupt__" in data:
+                    yield InterruptWaiting(message="Waiting for input…")
+                    continue
+                # Plan steps (todos) and host middleware phases are the only
+                # signal soothe gives us about *what* it is doing between tool
+                # calls; surface each change once.
+                step = update_progress(data)
+                if step is not None:
+                    key, payload = step
+                    if key != last_step_key:
+                        last_step_key = key
+                        yield Progress(
+                            stage="Step",
+                            message=step_message(payload),
+                            raw=payload,
+                        )
                 continue
 
             if mode != "messages":
@@ -153,6 +325,22 @@ async def iter_nano_runtime_events(
                         if tc_id in emitted_calls:
                             # Later updates refresh args; the call already started.
                             open_args[tc_id] = args
+                            # Tool args stream as partial JSON, so ToolStarted
+                            # usually carries none — refresh the status line
+                            # once they parse (Writing b1.txt, not Writing).
+                            # Once per call: partial JSON grows on every token,
+                            # and re-emitting it would flood the event stream.
+                            if args and name not in _QUIET_TOOLS and tc_id not in refreshed_calls:
+                                refreshed_calls.add(tc_id)
+                                yield Progress(
+                                    stage="Tool",
+                                    message=tool_call_summary(str(name), args),
+                                    raw={
+                                        "type": "soothe.tool.started",
+                                        "tool": name,
+                                        "args": args,
+                                    },
+                                )
                             continue
                         emitted_calls.add(tc_id)
                         open_tools[tc_id] = str(name)
@@ -197,6 +385,9 @@ async def iter_nano_runtime_events(
                 err_detail = tool_result_error_detail(message_obj.content)
                 ok = status != "error" and err_detail is None
                 detail = simplify_tool_error(err_detail) if err_detail else None
+                if str(name) in _QUIET_TOOLS and ok:
+                    # Plan bookkeeping already surfaced as a step event.
+                    continue
                 yield ToolCompleted(
                     tool=str(name),
                     ok=ok,