tau-coding-agent 0.7.2__tar.gz → 0.7.3__tar.gz

{tau_coding_agent-0.7.2/tau_coding_agent.egg-info → tau_coding_agent-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.7.2
+Version: 0.7.3
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/docs/auth.md

@@ -144,6 +144,7 @@ The provider ID used as the key in `auth.json` and the `{PROVIDER}_API_KEY` env
 | Google | `google` | `GOOGLE_API_KEY` |
 | Mistral | `mistral` | `MISTRAL_API_KEY` |
 | Fireworks AI | `fireworks` | `FIREWORKS_API_KEY` |
+| Hugging Face | `huggingface` | `HUGGINGFACE_API_KEY` |
 | Ollama | `ollama` | `OLLAMA_API_KEY` |
 
 ## Next Steps

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/docs/inference-providers.md

@@ -8,7 +8,8 @@ Tau supports the following inference providers:
 
 Built-in API-key providers are `openai`, `anthropic`, `google`, `nvidia`,
 `groq`, `openrouter`, `perplexity`, `xai`, `bedrock`, `kimi`, `minimax`,
-`cerebras`, `deepseek`, `zai`, `kilocode`, `fireworks`, and `mistral`.
+`cerebras`, `deepseek`, `zai`, `kilocode`, `fireworks`, `huggingface`, and
+`mistral`.
 
 Tau also includes local `ollama`, Google/Anthropic/OpenAI-compatible Vertex AI
 providers, and OAuth providers for OpenAI Codex, Claude Code, GitHub Copilot,
@@ -132,6 +133,34 @@ tau --model fireworks/accounts/fireworks/models/llama-v3p3-70b-instruct -p "Say
 - Uses the OpenAI-compatible completions API under the hood
 - Session affinity is maintained automatically via a per-request `x-session-affinity` header
 
+## Hugging Face
+
+Hugging Face's Inference Providers router gives OpenAI-compatible access to
+open-source models (DeepSeek, Llama, Qwen, Mixtral, and more) hosted across
+its partner inference providers.
+
+### Setup
+
+1. Create an account at [Hugging Face](https://huggingface.co)
+2. Generate an access token at [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens) (a `read` token is sufficient)
+3. Set the environment variable:
+
+```bash
+export HUGGINGFACE_API_KEY=hf_...
+```
+
+### Verify
+
+```bash
+tau --model huggingface/deepseek-ai/DeepSeek-V3-0324 -p "Say hello"
+```
+
+### Notes
+
+- Uses the OpenAI-compatible completions API under the hood, routed through `https://router.huggingface.co/v1`
+- Model IDs are Hugging Face Hub repo IDs (e.g. `meta-llama/Llama-3.3-70B-Instruct`)
+- Built-in model entries are pinned to a specific backend with `<repo>:<provider>` (e.g. `openai/gpt-oss-120b:groq`) rather than the router's default `:fastest` routing, since unpinned routing can silently switch to a backend with different tool-calling behavior. You can still use any model/backend combination the router supports via `tau --model huggingface/<repo>[:<provider>]` even if it isn't in the built-in list.
+
 ## Ollama (Local)
 
 Run open-source models locally without API keys or internet.

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.7.2"
+version = "0.7.3"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/agent/prompt/builder.py

@@ -225,7 +225,7 @@ def _detect_shell() -> str:
     if shell:
         return Path(shell).name
     if sys.platform == "win32":
-        if os.environ.get("PSModulePath"):
+        if os.environ.get("PSModulePath"):  # noqa: SIM112 — actual Windows env var casing
             return "powershell"
         comspec = os.environ.get("COMSPEC", "")
         return Path(comspec).stem if comspec else "cmd"

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/agent/service.py

@@ -544,7 +544,10 @@ class Agent:
         last = self._session_manager.find_last_assistant_message()
         if last is None:
             return False
-        if last.error_kind != ErrorKind.CONTEXT_OVERFLOW and not self._estimate_indicates_overflow():
+        if (
+            last.error_kind != ErrorKind.CONTEXT_OVERFLOW
+            and not self._estimate_indicates_overflow()
+        ):
             return False
 
         # Model-switch guard: the overflow error is from a different model if it predates

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/ask_user/component.py

@@ -7,6 +7,8 @@ from schema import FREEFORM_LABEL, AskUserOption  # type: ignore[import-not-foun
 
 from tau.tui.component import Component
 from tau.tui.input import InputEvent, KeyEvent
+from tau.tui.style import RESET
+from tau.tui.theme import LayoutTheme
 
 if TYPE_CHECKING:
     from tau.tui.buffer import Buffer
@@ -48,6 +50,7 @@ class _AskUserComponent(Component):
         allow_freeform: bool,
         multiline: bool,
         on_done: Any,
+        theme: LayoutTheme | None = None,
     ) -> None:
         self._question = question
         self._context = context
@@ -56,6 +59,7 @@ class _AskUserComponent(Component):
         self._allow_freeform = allow_freeform
         self._multiline = multiline
         self._on_done = on_done
+        self._theme = theme or LayoutTheme()
 
         self._cursor = 0
         self._checked: set[int] = set()
@@ -102,12 +106,13 @@ class _AskUserComponent(Component):
                 row += parse_ansi_wrapped_into(buf, x, y + row, line, width)
             return row
 
+        t = self._theme
         header: list[str] = []
         if self._context:
             for line in self._context.splitlines():
-                header.append(f"  \x1b[2m{line}\x1b[0m")
+                header.append(f"  {t.muted.sgr()}{line}{RESET}")
             header.append("")
-        header.append(f"  \x1b[1m{self._question}\x1b[0m")
+        header.append(f"  {t.accent.sgr()}{self._question}{RESET}")
         header.append("")
 
         header_rows = _write(header, area.x, area.y, area.width)
@@ -135,7 +140,9 @@ class _AskUserComponent(Component):
         preview_box = self._build_preview_box(preview, right_width, box_height)
 
         left_rows = _write(content_lines, area.x, body_y, left_width)
-        right_rows = _write(preview_box, area.x + left_width + self.PREVIEW_GAP, body_y, right_width)
+        right_rows = _write(
+            preview_box, area.x + left_width + self.PREVIEW_GAP, body_y, right_width
+        )
         col_rows = max(left_rows, right_rows)
 
         # Footer spans the FULL width beneath both columns — it's not part of
@@ -180,23 +187,23 @@ class _AskUserComponent(Component):
         for _ in range(self.ML_MIN_VISIBLE_ROWS - len(visible)):
             inner.append("")
         total = len(self._ml_lines)
+        muted = self._theme.muted.sgr()
         if total > self.ML_VISIBLE_ROWS:
             pct = int(self._ml_scroll_top / max(1, total - self.ML_VISIBLE_ROWS) * 100)
-            inner.append(f"  \x1b[2m↕ {pct}%\x1b[0m")
+            inner.append(f"  {muted}↕ {pct}%{RESET}")
         else:
             inner.append("")
         back = "Esc to cancel" if not self._options else "Esc to go back"
         footer = [
             "",
-            "  \x1b[2mEnter to submit  ·  \\+Enter or Shift+Enter for newline  ·  "
-            f"{back}\x1b[0m",
+            f"  {muted}Enter to submit  ·  \\+Enter or Shift+Enter for newline  ·  {back}{RESET}",
         ]
         return inner, footer
 
     def _build_singleline_body(self) -> tuple[list[str], list[str]]:
         back = "Esc to cancel" if not self._options else "Esc to go back"
         content = [f"  {self._freeform_value}█"]
-        footer = ["", f"  \x1b[2mEnter to submit  ·  {back}\x1b[0m"]
+        footer = ["", f"  {self._theme.muted.sgr()}Enter to submit  ·  {back}{RESET}"]
         return content, footer
 
     # Left margin + hanging indent for wrapped description lines beneath a
@@ -205,6 +212,13 @@ class _AskUserComponent(Component):
     DESC_INDENT = "      "
 
     def _build_list_body(self, width: int) -> tuple[list[str], list[str]]:
+        t = self._theme
+        muted = t.muted.sgr()
+        success = t.success.sgr()
+        accent = t.accent.sgr()
+        emphasis = t.emphasis.sgr()
+        arrow = t.selector_arrow
+
         inner: list[str] = []
         desc_width = max(width - len(self.DESC_INDENT), 10)
 
@@ -213,51 +227,56 @@ class _AskUserComponent(Component):
             title = FREEFORM_LABEL if is_freeform_row else self._options[i].title
             desc = "" if is_freeform_row else (self._options[i].description or "")
             is_cursor = i == self._cursor
-            cursor_mark = "❯" if is_cursor else " "
+
+            # Settings-selector style: per-span colors, no reversed background.
+            # The moving cursor arrow is always accent-colored; the row label
+            # is emphasis (selected) or muted (normal). Any inline color used
+            # inside the row — e.g. the checkbox glyph — must resume title_sgr
+            # right after its own RESET, since ANSI styles don't nest.
+            title_sgr = emphasis if is_cursor else muted
+            cursor_mark = f"{accent}{arrow}{RESET}{title_sgr}" if is_cursor else " "
 
             if is_freeform_row:
                 # Synthetic action row, not a countable option — keeps its own
-                # "❯" marker instead of a number.
-                marker = " ❯ "
+                # arrow marker instead of a number. Suppressed when this row
+                # is also the cursor row, since cursor_mark already shows an
+                # arrow there — otherwise it doubles up as "❯ ❯ Type…".
+                marker = f" {arrow} " if not is_cursor else "   "
             elif self._allow_multiple:
                 # Same tick glyphs as the /extensions config panel, paired with
-                # the option's ordinal number. Cursor rows get wrapped in
-                # reverse-video below, so leave them uncolored here — an
-                # embedded reset would cut the highlight short.
+                # the option's ordinal number.
                 if i in self._checked:
-                    box = "✔" if is_cursor else "\x1b[32m✔\x1b[0m"
+                    box = f"{success}✔{RESET}{title_sgr}"
                 else:
-                    box = "✖" if is_cursor else "\x1b[2m✖\x1b[0m"
+                    box = f"{muted}✖{RESET}{title_sgr}"
                 marker = f"{i + 1}. {box}"
             else:
                 marker = f"{i + 1}."
 
             row = f"  {cursor_mark} {marker} {title}"
-            if is_cursor:
-                row = f"\x1b[7m{row}\x1b[0m"
+            row = f"{title_sgr}{row}{RESET}"
             inner.append(row)
 
             # Description on its own hanging-indented line(s) below the title,
             # not packed onto the title row — at left-column widths that
             # would run straight into the next option's row.
             for line in textwrap.wrap(desc, desc_width) if desc else []:
-                inner.append(f"{self.DESC_INDENT}\x1b[2m{line}\x1b[0m")
+                inner.append(f"{self.DESC_INDENT}{muted}{line}{RESET}")
 
         hints = ["↑/↓ move", "Enter confirm", "Esc cancel"]
         if self._allow_multiple:
             hints.insert(1, "Space toggle")
-        footer = ["", "  \x1b[2m" + "  ·  ".join(hints) + "\x1b[0m"]
+        footer = ["", f"  {muted}" + "  ·  ".join(hints) + RESET]
         return inner, footer
 
-    @staticmethod
-    def _build_preview_box(preview: str | None, width: int, height: int) -> list[str]:
+    def _build_preview_box(self, preview: str | None, width: int, height: int) -> list[str]:
         """A bordered box of exactly ``height`` lines, sized to ``width``.
 
         Content beyond the available rows is truncated with a "N lines hidden"
         footer rather than growing the box — the box height is pinned to the
         paired option list so the two columns stay aligned row-for-row.
         """
-        dim, reset = "\x1b[2m", "\x1b[0m"
+        dim, reset = self._theme.border.sgr(), RESET
         inner_width = max(width - 4, 4)
         top = f"{dim}┌{'─' * (width - 2)}┐{reset}"
         bottom = f"{dim}└{'─' * (width - 2)}┘{reset}"
@@ -467,5 +486,5 @@ class _AskUserComponent(Component):
     def invalidate(self) -> None:
         pass
 
-    def set_theme(self, theme: Any) -> None:
-        pass
+    def set_theme(self, theme: LayoutTheme) -> None:
+        self._theme = theme

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/ask_user/tool.py

@@ -50,7 +50,7 @@ class AskUserTool(Tool):
                 "assumptions that would materially change the implementation. Each "
                 "question supports single-select, multi-select, and freeform text "
                 "answers, and up to 4 options when options are given. If you recommend a "
-                "specific option, list it first and append \"(Recommended)\" to its "
+                'specific option, list it first and append "(Recommended)" to its '
                 "title. Only available in an interactive TUI session."
             ),
             schema=AskUserParams,
@@ -112,9 +112,7 @@ class AskUserTool(Tool):
             else:
                 content = ", ".join(response["selections"])
 
-            answers.append(
-                {"question": question.question, "response": content, "raw": response}
-            )
+            answers.append({"question": question.question, "response": content, "raw": response})
 
         return ToolResult.ok(
             invocation.id,
@@ -149,6 +147,7 @@ class AskUserTool(Tool):
                 allow_freeform=question.allow_freeform,
                 multiline=question.multiline,
                 on_done=lambda v: (_on_done(v), done(v)),
+                theme=_theme,
             )
             if timeout:
                 timeout_ms = timeout

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/footer/__init__.py

@@ -65,6 +65,22 @@ def register(tau: ExtensionAPI) -> None:
             model_badge.update_context_from_ctx(ctx)
             _request_render(ctx)
 
+    @tau.on("message_update")
+    def on_message_update(event: Any, ctx: Any) -> None:
+        if not ctx.has_ui:
+            return
+        from tau.message.types import TextContent, ThinkingContent
+
+        msg = getattr(event, "message", None)
+        if msg is None:
+            return
+        contents = getattr(msg, "contents", [])
+        char_count = sum(
+            len(item.content) for item in contents if isinstance(item, (TextContent, ThinkingContent))
+        )
+        model_badge.set_live_estimate(char_count // 4)
+        _request_render(ctx)
+
     @tau.on("thinking_level_select")
     def on_thinking_level_select(event: Any, ctx: Any) -> None:
         if not ctx.has_ui:

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/footer/model.py

@@ -27,6 +27,10 @@ class ModelBadge(Component):
         self._context_window = 0
         self._thinking = False
         self._thinking_level = ""
+        # Char-based estimate of the still-streaming message's token count,
+        # added on top of _tokens so the percentage climbs live; cleared
+        # whenever a new authoritative count lands via set_context.
+        self._live_estimate = 0
 
     def set_model(self, model_id: str, provider: str, thinking: bool = False) -> None:
         self._model = model_id
@@ -39,6 +43,15 @@ class ModelBadge(Component):
     def set_context(self, tokens: int, context_window: int) -> None:
         self._tokens = tokens
         self._context_window = context_window
+        self._live_estimate = 0
+
+    def set_live_estimate(self, extra_tokens: int) -> None:
+        """Add an in-flight token estimate on top of the last known count.
+
+        Call this on each streamed delta of the current turn's response;
+        superseded by :meth:`set_context` once the real usage arrives.
+        """
+        self._live_estimate = extra_tokens
 
     def update_from_ctx(self, ctx: object) -> None:
         self.set_model(
@@ -89,8 +102,9 @@ class ModelBadge(Component):
         left = f"({self._provider}) {self._model}" if self._provider else self._model
         if self._thinking and self._thinking_level and self._thinking_level != "off":
             left += f" ∙ {self._thinking_level.title()}"
-        if self._context_window > 0 and self._tokens > 0:
-            pct = self._tokens / self._context_window * 100
+        tokens = self._tokens + self._live_estimate
+        if self._context_window > 0 and tokens > 0:
+            pct = tokens / self._context_window * 100
             label = f"{pct:.1f}%" if pct < 1 else f"{int(round(pct))}%"
             return f"{left}|{label}"
         return left

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/loop/__init__.py

@@ -30,7 +30,11 @@ from typing import TYPE_CHECKING
 sys.path.insert(0, str(Path(__file__).parent))
 
 from dispatch import _emit, _update_status, run_ticker  # type: ignore[import-not-found]
-from duration import format_duration, parse_duration, parse_loop_args  # type: ignore[import-not-found]
+from duration import (  # type: ignore[import-not-found]
+    format_duration,
+    parse_duration,
+    parse_loop_args,
+)
 from state import MAX_TASKS, LoopTask, SchedulerState  # type: ignore[import-not-found]
 
 if TYPE_CHECKING:
@@ -99,7 +103,11 @@ def register(tau: ExtensionAPI) -> None:
             return
 
         task = state.add(parsed["prompt"], parsed["interval_s"])
-        _emit(ctx, f"Loop scheduled every {format_duration(parsed['interval_s'])} (id: {task.id}). Expires in 3 days.")
+        _emit(
+            ctx,
+            f"Loop scheduled every {format_duration(parsed['interval_s'])} "
+            f"(id: {task.id}). Expires in 3 days.",
+        )
         if parsed.get("note"):
             _emit(ctx, parsed["note"])
         _update_status(ctx, state)
@@ -117,7 +125,9 @@ def register(tau: ExtensionAPI) -> None:
                 "Delete",
                 "Back",
             ]
-            choice = await ui.select(f"Loop {task.id} — every {format_duration(task.interval_s)}", actions)
+            choice = await ui.select(
+                f"Loop {task.id} — every {format_duration(task.interval_s)}", actions
+            )
             if choice is None or choice == "Back":
                 return
 
@@ -158,7 +168,9 @@ def register(tau: ExtensionAPI) -> None:
 
     async def _show_picker(ctx: ExtensionContext, ui: UIContext) -> None:
         while True:
-            options = [_loop_label(t) for t in sorted(state.tasks.values(), key=lambda t: t.next_run_at)]
+            options = [
+                _loop_label(t) for t in sorted(state.tasks.values(), key=lambda t: t.next_run_at)
+            ]
             options.append("+ New loop")
             if state.tasks:
                 options.append("Clear all loops")
@@ -174,7 +186,9 @@ def register(tau: ExtensionAPI) -> None:
                 continue
 
             if choice == "Clear all loops":
-                ok = await ui.confirm("Clear all loops?", f"This deletes all {len(state.tasks)} loop(s).")
+                ok = await ui.confirm(
+                    "Clear all loops?", f"This deletes all {len(state.tasks)} loop(s)."
+                )
                 if ok:
                     n = state.clear()
                     ui.notify(f"Cleared {n} loop{'s' if n != 1 else ''}.")
@@ -199,7 +213,8 @@ def register(tau: ExtensionAPI) -> None:
 
     tau.register_command(
         "loop",
-        "Manage recurring prompts: /loop opens the loop manager, /loop <period> <task> creates one directly",
+        "Manage recurring prompts: /loop opens the loop manager, "
+        "/loop <period> <task> creates one directly",
         cmd_loop,
         argument_hint="<period> <task>",
         get_argument_completions=_get_argument_completions,

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/loop/duration.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import math
 import re
-from typing import Optional
 
 ONE_MINUTE = 60
 FIFTEEN_MINUTES = 15 * ONE_MINUTE
@@ -17,7 +16,7 @@ _DURATION_WORD = re.compile(
 )
 
 
-def parse_duration(text: str) -> Optional[float]:
+def parse_duration(text: str) -> float | None:
     """Parse '5m', '2h', '30 seconds', etc. into seconds."""
     raw = text.strip().lower()
     if not raw:
@@ -43,7 +42,7 @@ def parse_duration(text: str) -> Optional[float]:
     return None
 
 
-def normalize_duration(seconds: float) -> tuple[float, Optional[str]]:
+def normalize_duration(seconds: float) -> tuple[float, str | None]:
     """Round up to minute granularity, matching the minimum tick resolution."""
     if seconds <= 0:
         return ONE_MINUTE, "Rounded up to 1m (minimum interval)."
@@ -61,7 +60,7 @@ def format_duration(seconds: float) -> str:
     return f"{int(seconds // ONE_MINUTE)}m"
 
 
-def _extract_leading_duration(text: str) -> Optional[tuple[float, str]]:
+def _extract_leading_duration(text: str) -> tuple[float, str] | None:
     tokens = text.strip().split()
     if len(tokens) < 2:
         return None
@@ -78,7 +77,7 @@ def _extract_leading_duration(text: str) -> Optional[tuple[float, str]]:
     return None
 
 
-def _extract_trailing_duration(text: str) -> Optional[tuple[float, str]]:
+def _extract_trailing_duration(text: str) -> tuple[float, str] | None:
     tokens = text.strip().split()
     if len(tokens) < 2:
         return None
@@ -95,8 +94,8 @@ def _extract_trailing_duration(text: str) -> Optional[tuple[float, str]]:
     return None
 
 
-def parse_loop_args(text: str) -> Optional[dict]:
-    """/loop 5m <task>  |  /loop <task> every 2h  |  /loop <task> 5m  |  /loop <task> (default 10m)."""
+def parse_loop_args(text: str) -> dict | None:
+    """/loop 5m <task> | /loop <task> every 2h | /loop <task> 5m | /loop <task> (default 10m)."""
     raw = text.strip()
     if not raw:
         return None

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/loop/state.py

@@ -8,9 +8,13 @@ import string
 import time
 from dataclasses import asdict, dataclass
 from pathlib import Path
-from typing import Optional
 
-from duration import FIFTEEN_MINUTES, ONE_MINUTE, THREE_DAYS, format_duration  # type: ignore[import-not-found]
+from duration import (  # type: ignore[import-not-found]
+    FIFTEEN_MINUTES,
+    ONE_MINUTE,
+    THREE_DAYS,
+    format_duration,
+)
 
 MAX_TASKS = 50
 
@@ -23,10 +27,10 @@ class LoopTask:
     created_at: float
     next_run_at: float
     interval_s: float
-    expires_at: Optional[float] = None
+    expires_at: float | None = None
     jitter_s: float = 0
-    last_run_at: Optional[float] = None
-    last_status: Optional[str] = None
+    last_run_at: float | None = None
+    last_status: str | None = None
     run_count: int = 0
     pending: bool = False
 
@@ -56,7 +60,7 @@ def _hash_id(task_id: str) -> int:
 class SchedulerState:
     def __init__(self) -> None:
         self.tasks: dict[str, LoopTask] = {}
-        self.storage_path: Optional[Path] = None
+        self.storage_path: Path | None = None
         self.dispatching = False
 
     def set_storage(self, cwd: Path) -> None:
@@ -76,7 +80,9 @@ class SchedulerState:
                 if not item.get("id") or not item.get("prompt"):
                     continue
                 item = {**item, "pending": False}
-                task = LoopTask(**{k: v for k, v in item.items() if k in LoopTask.__dataclass_fields__})
+                task = LoopTask(
+                    **{k: v for k, v in item.items() if k in LoopTask.__dataclass_fields__}
+                )
                 if task.expires_at and now >= task.expires_at:
                     continue
                 self.tasks[task.id] = task
@@ -90,7 +96,9 @@ class SchedulerState:
             self.storage_path.parent.mkdir(parents=True, exist_ok=True)
             data = {
                 "version": 1,
-                "tasks": [asdict(t) for t in sorted(self.tasks.values(), key=lambda t: t.next_run_at)],
+                "tasks": [
+                    asdict(t) for t in sorted(self.tasks.values(), key=lambda t: t.next_run_at)
+                ],
             }
             tmp = self.storage_path.with_suffix(".json.tmp")
             tmp.write_text(json.dumps(data, indent=2))

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/subagent/subagent_schema.py

@@ -18,9 +18,7 @@ class TaskItem(BaseModel):
     agent: str = Field(..., description="Name of the agent to invoke.")
     task: str = Field(..., description="Task to delegate to the agent.")
     cwd: str | None = Field(default=None, description="Working directory for the agent process.")
-    context: Literal["fresh", "fork"] | None = Field(
-        default=None, description=_CONTEXT_DESCRIPTION
-    )
+    context: Literal["fresh", "fork"] | None = Field(default=None, description=_CONTEXT_DESCRIPTION)
 
 
 class ChainItem(BaseModel):
@@ -30,9 +28,7 @@ class ChainItem(BaseModel):
         description="Task with an optional '{previous}' placeholder for the prior step's output.",
     )
     cwd: str | None = Field(default=None, description="Working directory for the agent process.")
-    context: Literal["fresh", "fork"] | None = Field(
-        default=None, description=_CONTEXT_DESCRIPTION
-    )
+    context: Literal["fresh", "fork"] | None = Field(default=None, description=_CONTEXT_DESCRIPTION)
 
 
 class SubagentParams(BaseModel):
@@ -47,9 +43,7 @@ class SubagentParams(BaseModel):
             "need to set it explicitly."
         ),
     )
-    agent: str | None = Field(
-        default=None, description="Target agent name for action='get'."
-    )
+    agent: str | None = Field(default=None, description="Target agent name for action='get'.")
     spawn: list[TaskItem] | None = Field(
         default=None,
         description=(

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/todo/__init__.py

@@ -59,6 +59,7 @@ class TodoBoard:
         self._shown = False
 
     def _lines(self, theme: Any) -> list[str]:
+        from tau.modes.interactive.components.message_list import apply_render_shell
         from tau.tui.style import apply_style
 
         glyphs = {
@@ -67,16 +68,14 @@ class TodoBoard:
             "done": ("✓", theme.success),
             "failed": ("✗", theme.error),
         }
-        remaining = self._state.remaining()
-        header = (
-            f"{apply_style(theme.warning, '☐')} "
-            f"{apply_style(theme.emphasis, f'Todos ({len(remaining)} pending)')}"
-        )
-        lines = [header]
+        items = []
         for item in self._state.items:
             glyph, style = glyphs[item.status]
-            lines.append(f"  {apply_style(style, glyph)} {item.id}. {item.subject}")
-        return lines
+            subject = item.subject
+            if item.status == "done":
+                subject = apply_style(style.patch(theme.strikethrough), subject)
+            items.append(f"{apply_style(style, glyph)} {item.id}. {subject}")
+        return apply_render_shell(items, theme)
 
     def sync(self, ctx: ExtensionContext) -> None:
         ui = ctx.ui
@@ -148,7 +147,9 @@ def register(tau: ExtensionAPI) -> None:
             ("Done", "✓", state.list("done")),
             ("Failed", "✗", state.list("failed")),
         ]
-        header = " · ".join(f"{len(items)} {label.lower()}" for label, _, items in sections if items)
+        header = " · ".join(
+            f"{len(items)} {label.lower()}" for label, _, items in sections if items
+        )
         lines = [header]
         for label, glyph, items in sections:
             if not items:

{tau_coding_agent-0.7.2 → tau_coding_agent-0.7.3}/tau/builtins/extensions/todo/todo_schema.py

@@ -54,7 +54,9 @@ class TodoParams(BaseModel):
     )
     append_note: str | None = Field(
         default=None,
-        description="Append a paragraph to the task's existing description. Only used by action='update'.",
+        description=(
+            "Append a paragraph to the task's existing description. Only used by action='update'."
+        ),
     )
     status: Literal["pending", "in_progress", "done", "failed"] | None = Field(
         default=None,