task tool: parallel fan-out, robust subagent loop, proper card UI

The `task` tool was serialised and fragile — the opposite of its purpose.

PARALLELISM (the headline): task carries Effect::Exec for PERMISSION
(a subagent can run bash, must gate like bash), and the scheduler read
the same effects — Exec means "exclusive", so every task ran alone and
blocked all sibling tools. New spec::sched_effects() splits the two
questions: task SCHEDULES as {ReadFs, Net} (composable with reads,
other tasks, disjoint-path writers) while its permission gate stays
Exec. A fan-out of subagents now genuinely runs concurrently — the
whole point of the tool. scheduler_path_test +3 cases (fan-out all
parallel, task+reads compose, bash still excludes task).

ROBUSTNESS (the "fails a lot"):
  • Provider-agnostic: the runner drove provider::anthropic::
    run_stream_sync directly — every task 400'd on OpenAI-compat/
    Ollama (wrong wire, wrong auth) and fresh_auth_header would clobber
    a non-Anthropic key with Anthropic credentials. Config gains the
    SAME stream seam Deps::stream uses (routes on provider::active()
    at call time); main.cpp installs it. fresh_auth_header now gated
    on Kind::Anthropic. Null seam falls back to the old transport.
  • Transient stream errors (429/529, TLS reset) RETRY with 1/2/4s
    backoff (3 attempts, reset on success) instead of killing the
    whole subagent; the partial assistant turn is dropped before
    retry so the wire pairing stays valid.
  • Truncated tool-args JSON is SALVAGED via close_partial_json
    (guarded by ended_inside_string so a half-written body never
    silently runs), and a bad-args call now counts as a tool
    round-trip — the model sees the error and re-emits, instead of
    the loop breaking out and the task dying on the first parse hiccup.
  • Repeat-failure breaker inside the loop: identical call failed 3×
    → stop and report, same rule as the parent's doom-loop breaker.
  • Progress pump throttled to ~12 fps (was per-delta) so a parallel
    fan-out doesn't flood the UI msg queue.

UI: task is now "Agent" with its own identity hue (bright magenta) and
"agent" category chip; detail line = "type · description" (agent type
leads — it's the discriminator in a fan-out; falls back to the prompt's
first line, UTF-8-safe clamp); settled detail keeps just "N turns"
(type no longer duplicated). Live activity feed shows ✓/✗ with the
tool's target (path/pattern/command) instead of bare names, plus ↻
retry lines; live card body grew to 8 rows (report stays a 5-row
glance, full text in transcript + Ctrl+O viewer).

Author: 1ay1

include/agentty/tool/spec.hpp

@@ -229,6 +229,31 @@ inline constexpr std::array kCatalog = {
     return nullptr;
 }
 
+// ── Scheduling-effects view ──────────────────────────────────────
+// `effects` answers the PERMISSION question ("how much trust does this
+// tool need?"); this answers the CONCURRENCY question ("what does it
+// actually contend on?"). They coincide for every tool except `task`:
+//
+//   • task carries Effect::Exec for permission — a subagent can run bash,
+//     so it must gate like bash.
+//   • But for SCHEDULING, Exec means "exclusive: unbounded blast radius,
+//     nothing else may run" — which serialised every task and blocked all
+//     sibling tools behind a running subagent. That defeats the tool's
+//     entire purpose: task exists precisely so the model can fan out
+//     several isolated investigations CONCURRENTLY (Claude Code runs its
+//     Task tool in parallel waves for the same reason). The subagent's
+//     own tool calls are individually effect-gated + path-scheduled
+//     inside its loop, so the parent scheduling it as coarse-Exec is
+//     double-counting contention that the inner dispatch already manages.
+//
+// So task schedules as {ReadFs, Net} — composable with reads, with other
+// tasks, and with disjoint-path writers — while its permission gate stays
+// Exec. Any future tool with the same split gets a row here.
+[[nodiscard]] constexpr EffectSet sched_effects(const ToolSpec& s) noexcept {
+    if (s.name == "task") return {Effect::ReadFs, Effect::Net};
+    return s.effects;
+}
+
 // Fixed-string non-type template parameter so a tool factory can write
 // `spec::require<"bash">()` and have the misspelling caught at compile
 // time. The instantiation site evaluates `lookup` in a constant

include/agentty/tool/subagent.hpp

@@ -8,9 +8,11 @@
 // without a default model), the tool returns a clear "unavailable"
 // error instead of crashing.
 
+#include <functional>
 #include <string>
 
 #include "agentty/auth/auth.hpp"
+#include "agentty/provider/provider.hpp"
 
 namespace agentty::tools::subagent {
 
@@ -19,6 +21,16 @@ struct Config {
     auth::AuthHeader auth;       // wire credential for the sub-stream
     std::string      model;      // model id for sub-agent turns
     bool             installed = false;
+
+    // Provider-agnostic stream seam — the SAME dispatch main.cpp installs
+    // into Deps::stream (routes on provider::active() at call time:
+    // Anthropic / OpenAI-compat / Ollama native). Installed alongside auth
+    // so a subagent talks to whatever backend the USER selected instead of
+    // hardcoding the Anthropic transport — previously `task` failed on
+    // every non-Anthropic provider (wrong wire, wrong auth). Null ⇒ the
+    // runner falls back to the Anthropic transport (old behaviour, keeps
+    // tests that install only auth+model working).
+    std::function<void(provider::Request, provider::EventSink)> stream;
 };
 
 // Install the subagent config (call once at startup, after auth resolves).

src/runtime/app/cmd_factory.cpp

@@ -774,8 +774,13 @@ namespace {
 } // namespace
 
 SchedDecision schedule_parallel_batch(const std::vector<ToolUse>& batch) {
+    // Scheduling reads spec::sched_effects, NOT the raw permission effects:
+    // `task` gates as Exec (a subagent can run bash) but SCHEDULES as
+    // {ReadFs, Net} so a fan-out of subagents actually runs concurrently —
+    // the whole point of the tool. See spec.hpp::sched_effects.
     auto effects_of = [](const ToolName& n) -> tools::EffectSet {
-        if (const auto* sp = tools::spec::lookup(n.value)) return sp->effects;
+        if (const auto* sp = tools::spec::lookup(n.value))
+            return tools::spec::sched_effects(*sp);
         return tools::EffectSet{{tools::Effect::Exec}};
     };
     tools::EffectSet active_effects;

src/runtime/main.cpp

@@ -397,18 +397,21 @@ int main(int argc, char** argv) {
         .auth          = provider_auth,
     });
 
-    // ── Wire the subagent (`task` tool) seam ────────────────────────────
+    // ── Wire the subagent (`task` tool) seam ────────────────────
     // Process-global config the `task` tool reads to spin up an isolated
     // sub-agent loop. Resolve the model the same way the TUI / ACP paths
-    // do (-m override → saved setting → built-in default).
+    // do (-m override → saved setting → built-in default). The stream fn
+    // is the SAME provider dispatch Deps::stream uses (routes on
+    // provider::active() at call time), so subagents work on Anthropic,
+    // OpenAI-compat, and Ollama alike — not just the Anthropic transport.
     {
         auto sa_settings = persistence::load_settings();
         std::string sa_model =
             !args.cli_model.empty()       ? args.cli_model
           : !sa_settings.model_id.empty() ? sa_settings.model_id.value
           :                                 std::string{"claude-opus-4-5"};
         tools::subagent::install(tools::subagent::Config{
-            provider_auth, std::move(sa_model), true});
+            provider_auth, std::move(sa_model), true, stream_fn});
     }
 
     // ── MCP server mode: serve agentty's native tools over MCP (stdio) ──

src/runtime/view/thread/turn/agent_timeline/tool_body_preview.cpp

@@ -568,18 +568,20 @@ maya::ToolBodyPreview::Config tool_body_preview_config(
     //    BashOutput gives the tail-oriented "watch it work" look while
     //    running; CodeBlock shows the full report once settled.
     if (n == "task") {
-        // Hard 5-row ceiling on the card body: a subagent report can be
-        // long, but the timeline card is a glance-able summary — the full
-        // report is always in the transcript. Both the live feed and the
-        // settled report are head-capped to kTaskBodyRows.
-        constexpr std::size_t kTaskBodyRows = 5;
+        // Card body ceilings: the LIVE feed gets more room (it's the only
+        // window into what the subagent is doing — ⚙ calls, ✓/✗ results,
+        // ↻ retries — and it's transient), while the SETTLED report stays a
+        // tight glance-able summary; the full report is in the transcript
+        // and the Ctrl+O viewer.
+        constexpr std::size_t kTaskLiveRows   = 8;
+        constexpr std::size_t kTaskReportRows = 5;
         if (tc.is_running()) {
             if (!tc.progress_text().empty()) {
                 out.kind = Kind::BashOutput;
                 // BashOutput is tail-oriented (newest activity at the
                 // bottom) — keep the last few feed lines so the running
                 // card shows the CURRENT step, not the stale header.
-                out.text = tail_window(tc.progress_text(), kTaskBodyRows);
+                out.text = tail_window(tc.progress_text(), kTaskLiveRows);
                 out.text_color = text_tertiary;
                 out.is_streaming = true;
             }
@@ -598,8 +600,8 @@ maya::ToolBodyPreview::Config tool_body_preview_config(
                     body.remove_prefix(1);
             }
             out.kind = Kind::CodeBlock;
-            // keep 4 content lines + 1 "⋯ N more" marker = 5 rows max.
-            out.text = head_window(body, kTaskBodyRows - 1);
+            // keep content lines + 1 "⋯ N more" marker = ceiling rows max.
+            out.text = head_window(body, kTaskReportRows - 1);
             out.text_color = text_tertiary;
             // We pre-sliced to the ceiling; render it verbatim (no further
             // head+tail elision that would fight our marker).

src/runtime/view/thread/turn/agent_timeline/tool_helpers.cpp

@@ -9,6 +9,7 @@
 
 #include "agentty/runtime/view/palette.hpp"
 #include "agentty/runtime/view/thread/turn/agent_timeline/tool_args.hpp"
+#include "agentty/tool/util/utf8.hpp"
 
 namespace agentty::ui {
 
@@ -33,6 +34,7 @@ std::string tool_display_name(const std::string& n) {
     if (n == "git_diff")        return "Git Diff";
     if (n == "git_log")         return "Git Log";
     if (n == "git_commit")      return "Git Commit";
+    if (n == "task")            return "Agent";
     return n;
 }
 
@@ -58,6 +60,7 @@ maya::Color tool_category_color(const std::string& n) {
     if (n == "edit" || n == "write")  return role_brand;
     if (n == "bash")                  return code_text;
     if (n == "todo")                  return status_warn;
+    if (n == "task")                  return role_brand_alt;   // agent identity
     if (n.rfind("git_", 0) == 0)      return role_info;
     return code_path;
 }
@@ -66,6 +69,7 @@ std::string_view tool_category_label(const std::string& n) {
     if (n == "edit" || n == "write")  return "mutate";
     if (n == "bash")                  return "execute";
     if (n == "todo")                  return "plan";
+    if (n == "task")                  return "agent";
     if (n.rfind("git_", 0) == 0)      return "vcs";
     return "inspect";
 }
@@ -384,17 +388,37 @@ std::string tool_timeline_detail(const ToolUse& tc) {
         return "\xe2\x80\xa6";
     }
     if (n == "task") {
-        // Header detail = the model's one-line display_description; once the
-        // subagent settles, append its turn count parsed from the report
-        // header ("Subagent report (N turns):") so the card doubles as a
-        // compact result log without expanding.
-        std::string detail = safe("display_description");
-        if (detail.empty()) detail = "subagent";
+        // Header detail: "type · what it's doing". The agent type leads —
+        // in a parallel fan-out of subagents it's the discriminator the
+        // user scans for. Falls back to the prompt's first line when the
+        // model omitted display_description. Once settled, append the turn
+        // count parsed from the report header ("Subagent report (type, N
+        // turns):") so the card doubles as a compact result log.
+        std::string type = safe("agent_type");
+        if (type.empty()) type = "general";
+        std::string what = safe("display_description");
+        if (what.empty()) {
+            what = safe("prompt");
+            if (auto nl = what.find('\n'); nl != std::string::npos)
+                what.resize(nl);
+            if (what.size() > 60) {
+                what.resize(tools::util::safe_utf8_cut(what, 57));
+                what += "\xe2\x80\xa6";
+            }
+        }
+        std::string detail = type;
+        if (!what.empty()) detail += "  \xc2\xb7  " + what;
         if (tc.is_terminal()) {
             const auto& out = tc.output();
             if (auto p = out.find("report ("); p != std::string::npos) {
-                if (auto end = out.find(')', p); end != std::string::npos)
-                    detail += "  \xc2\xb7  " + out.substr(p + 8, end - (p + 8));
+                if (auto end = out.find(')', p); end != std::string::npos) {
+                    // "(type, N turns)" — keep only the "N turns" half; the
+                    // type is already leading the detail.
+                    std::string inner = out.substr(p + 8, end - (p + 8));
+                    if (auto comma = inner.find(", "); comma != std::string::npos)
+                        inner = inner.substr(comma + 2);
+                    detail += "  \xc2\xb7  " + inner;
+                }
             }
             if (tc.is_failed()) detail += "  \xc2\xb7  failed";
         }