separator `0x1F`. Durable job reports used to post the raw bytes. This

  module is the server-side decoder so a timeout or completion never writes

  `Ttoolu_…0executeVGVybWluYWw=` into the conversation.

  `decode/1` renders the whole stream, prose and tool lines alike. A chat

  message wants less than that, so `summarize/1` splits the two: the agent's

  own words stay, and the tool-by-tool log becomes a count.

  """

  @record_separator <<30>>

  @spec decode(term()) :: String.t()

  def decode(binary) when is_binary(binary) do

    binary

    |> walk([], %{})

    |> finalize()

    |> entries()

    |> render()

  end

  def decode(_other), do: ""

  @doc """

  Splits the stream into what a conversation can carry and what it cannot.

  Returns the agent's own prose, its notes, and the tool calls that failed —

  the parts that explain an outcome — plus the total number of tool calls.

  The tool-by-tool log belongs to the live delegation rail: pasted into a

  message it buries the report under hundreds of `Terminal: …` lines, so the

  caller names the count instead.

  """

  @spec summarize(term()) :: {String.t(), non_neg_integer()}

  def summarize(binary) when is_binary(binary) do

    entries = entries(binary)

    text =

      entries

      |> Enum.reject(&(&1.kind == :tool and &1.status != :failed))

      |> render()

    {text, Enum.count(entries, &(&1.kind == :tool))}

  end

  def summarize(_other), do: {"", 0}

  defp walk(<<@record_separator, rest::binary>>, acc, tools) do

    case take_line(rest) do

      {line, remaining} ->

      ["N", encoded | rest] ->

        tone = Enum.at(rest, 0) || "info"

        {append_block(acc, note_line(decode64(encoded), tone)), tools}

        {append_block(:note, acc, note_line(decode64(encoded), tone), nil), tools}

      _other ->

        {acc, tools}

    if tool.emitted? do

      {acc, tools}

    else

      {append_block(acc, tool_line(tool, if(phase == "2", do: :failed, else: :done))),

      status = if phase == "2", do: :failed, else: :done

      {append_block(:tool, acc, tool_line(tool, status), status),

       Map.update!(tools, id, &Map.put(&1, :emitted?, true))}

    end

  end

  defp maybe_emit_tool(acc, _id, _phase, tools), do: {acc, tools}

  defp finalize({acc, tools}) do

  # The stream in reading order, each block tagged with what it is, so a caller

  # can keep the prose without the tool log.

  defp entries(binary) do

    {acc, tools} = walk(binary, [], %{})

    unfinished =

      tools

      |> Enum.reject(fn {_id, tool} -> tool.emitted? or tool.phase in ["1", "2"] end)

      |> Enum.map(fn {_id, tool} -> tool_line(tool, :running) end)

      |> Enum.map(fn {_id, tool} -> entry(:tool, tool_line(tool, :running), :running) end)

    [Enum.reverse(acc), unfinished]

    |> List.flatten()

    |> Enum.reject(&(&1 in [nil, ""]))

    |> Enum.join("\n\n")

    Enum.reverse(acc) ++ unfinished

  end

  defp render(entries) do

    entries

    |> Enum.map_join("\n\n", & &1.text)

    |> String.trim()

  end

  defp entry(kind, text, status), do: %{kind: kind, text: text, status: status}

  defp append_prose(acc, text) do

    trimmed = String.trim(text)

    if trimmed == "", do: acc, else: [trimmed | acc]

    if trimmed == "", do: acc, else: [entry(:prose, trimmed, nil) | acc]

  end

  defp append_block(acc, block) do

    if block in [nil, ""], do: acc, else: [block | acc]

  end

  defp append_block(_kind, acc, block, _status) when block in [nil, ""], do: acc

  defp append_block(kind, acc, block, status), do: [entry(kind, block, status) | acc]

  defp tool_line(tool, status) do

    label = Map.get(@kind_labels, tool.kind, "")

  alias OpenAgents.Cluster.Sessions

  alias OpenAgents.Computer.AcpTranscript

  @maximum_report_output 6_000

  # A report is a chat message, not a terminal window. It carries what the

  # agent said and any tool call that failed; the tool-by-tool log stays in the

  # live delegation rail. The bound is characters of that composed body.

  @maximum_report_output 2_000

  @maximum_detail 500

  def start_link(job_id) do

    GenServer.start_link(__MODULE__, job_id, name: via(job_id))

  defp human_status("refused"), do: "refused"

  defp human_status(other), do: "ended (#{other})"

  defp detail_line(detail) when is_binary(detail) and detail != "", do: detail

  # The detail is controller-reported text: bound it before it reaches a message.

  defp detail_line(detail) when is_binary(detail) and detail != "",

    do: String.slice(detail, 0, @maximum_detail)

  defp detail_line(_detail), do: nil

  # The conversation gets the agent's answer, not its keystrokes. Posting the

  # whole decoded transcript dumped hundreds of `Terminal: …` lines into the

  # chat the moment a long delegation ended. What survives here is the prose,

  # the tool calls that failed, and a line counting the rest, so the work is

  # named without being replayed.

  defp output_block(output) when is_binary(output) and output != "" do

    transcript = AcpTranscript.decode(output)

    {summary, tool_count} = AcpTranscript.summarize(output)

    if transcript == "" do

      nil

    else

      bound_transcript(transcript)

    case Enum.reject([bound_report(summary), tool_count_line(tool_count)], &(&1 in [nil, ""])) do

      [] -> nil

      parts -> Enum.join(parts, "\n\n")

    end

  end

  defp output_block(_output), do: nil

  defp bound_transcript(transcript) do

    if String.length(transcript) <= @maximum_report_output do

      transcript

  defp tool_count_line(0), do: nil

  defp tool_count_line(1), do: "The agent ran 1 tool call on the machine."

  defp tool_count_line(count), do: "The agent ran #{count} tool calls on the machine."

  defp bound_report(summary) do

    if String.length(summary) <= @maximum_report_output do

      summary

    else

      String.slice(transcript, 0, @maximum_report_output) <> "\n\n[transcript truncated]"

      String.slice(summary, 0, @maximum_report_output) <> "\n\n[report truncated]"

    end

  end

    assert report =~ "3 hits"

  end

  test "summarize keeps the prose and failures, and counts the rest" do

    stream =

      "I read the failing test and fixed the selector.\n" <>

        frame("T", ["toolu_01run", "1", "execute", b64("git status"), b64("On branch main")]) <>

        frame("T", ["toolu_02read", "1", "read", b64("chat_live.ex"), b64("defmodule")]) <>

        frame("T", ["toolu_03edit", "2", "edit", b64("chat_live.ex"), b64("User refused")]) <>

        frame("N", [b64("Permission denied: Edit"), "warn"])

    assert {text, 3} = AcpTranscript.summarize(stream)

    # What explains the outcome stays: the agent's words, its notes, the failure.

    assert text =~ "I read the failing test and fixed the selector."

    assert text =~ "Edit: chat_live.ex (failed)"

    assert text =~ "Warning: Permission denied: Edit"

    # The tool-by-tool log does not.

    refute text =~ "git status"

    refute text =~ "On branch main"

    refute text =~ "Read: chat_live.ex"

  end

  test "summarize counts a tool that never finished, and empties safely" do

    stream = frame("T", ["toolu_01open", "0", "read", b64("chat_live.ex"), ""])

    assert {"", 1} = AcpTranscript.summarize(stream)

    assert AcpTranscript.summarize("") == {"", 0}

    assert AcpTranscript.summarize(nil) == {"", 0}

  end

  defp frame(kind, fields) do

    @rs <> Enum.join([kind | fields], @us) <> "\n"

  end

defmodule OpenAgents.Work.DelegationReportTest do

  @moduledoc """

  What a finished delegation is allowed to post into the conversation.

  A delegation's report becomes an assistant message, so it is chat, not a

  terminal window. The regression this pins: a long delegation used to end by

  dumping its whole decoded ACP transcript — hundreds of `Terminal: …` lines,

  each command repeated as title and detail — into the transcript, ending in

  `[transcript truncated]`. The tool-by-tool log belongs to the live

  delegation rail; the message carries what the agent said.

  """

  use OpenAgents.DataCase

  alias OpenAgents.Conversations.Message

  alias OpenAgents.Support.FakeController

  alias OpenAgents.{Accounts, Conversations, Machines, Work}

  @record_separator <<30>>

  @unit_separator <<31>>

  test "a completed delegation reports the agent's prose, never its tool log" do

    %{conversation: conversation, machine: machine} = delegation_owner("deleg-report-prose")

    connect(machine.id, fn {:agent, request_id, _payload, caller} ->

      FakeController.chunk(caller, request_id, noisy_transcript())

      FakeController.exit(caller, request_id, %{

        "status" => "completed",

        "stop_reason" => "end_turn",

        "session_id" => "acp-report-1",

        "duration_ms" => 118_000,

        "truncated" => false,

        "detail" => ""

      })

    end)

    job = run_delegation(conversation, machine)

    assert job.status == "completed"

    content = report_content(job)

    # The agent's own words, the session line the resume path parses, and the

    # one tool call that failed — the parts that explain the outcome.

    assert content =~ "Delegation to claude"

    assert content =~ "Session: acp-report-1"

    assert content =~ "I read the failing test and fixed the selector."

    assert content =~ "Edit: chat_live.ex (failed)"

    # Never the log of everything it typed.

    refute content =~ "Terminal:"

    refute content =~ "/usr/bin/bash -lc"

    refute content =~ "[transcript truncated]"

    # The work is still named, and the whole message stays chat-sized.

    assert content =~ "The agent ran 61 tool calls on the machine."

    assert String.length(content) < 1_000

  end

  test "cancelling a delegation reports the cancellation, never a partial transcript" do

    %{conversation: conversation, machine: machine} = delegation_owner("deleg-report-cancel")

    # A delegation that streams and never returns: the owner stops it from the

    # live panel while the tool log is still growing.

    connect(machine.id, fn {:agent, request_id, _payload, caller} ->

      FakeController.chunk(caller, request_id, noisy_transcript())

    end)

    {:ok, started} = Work.start_delegation(delegation_attributes(conversation, machine))

    assert eventually(fn -> Work.get_job!(started.id).status == "running" end)

    :ok = Work.cancel_active_delegations(conversation.id)

    assert eventually(fn -> Work.get_job!(started.id).status == "cancelled" end)

    content = started.id |> Work.get_job!() |> report_content()

    assert content =~ "Delegation cancelled by the owner."

    refute content =~ "Terminal:"

    refute content =~ "/usr/bin/bash -lc"

    refute content =~ "[transcript truncated]"

  end

  # ── helpers ──────────────────────────────────────────────────────────────

  # One realistic delegation stream: a sentence of prose, 60 successful

  # terminal calls whose title and detail both carry the command, one failed

  # edit, and a permission note.

  defp noisy_transcript do

    command = ~s(/usr/bin/bash -lc "sed -n 1,200p lib/openagents_web/live/chat_live.ex")

    terminals =

      Enum.map_join(1..60, "", fn index ->

        id = "toolu_0#{index}"

        frame("T", [id, "0", "execute", encode("Terminal"), ""]) <>

          frame("T", [id, "1", "execute", encode(command), encode(command)])

      end)

    "I read the failing test and fixed the selector.\n" <>

      terminals <>

      frame("T", [

        "toolu_0edit",

        "2",

        "edit",

        encode("chat_live.ex"),

        encode("User refused permission")

      ]) <> frame("N", [encode("Permission denied: Edit"), "warn"])

  end

  defp frame(kind, fields) do

    @record_separator <> Enum.join([kind | fields], @unit_separator) <> "\n"

  end

  defp encode(text), do: Base.encode64(text)

  defp run_delegation(conversation, machine) do

    {:ok, job} = Work.start_delegation(delegation_attributes(conversation, machine))

    assert eventually(fn -> Work.get_job!(job.id).status in Work.Job.terminal_statuses() end)

    Work.get_job!(job.id)

  end

  # The assistant message the delegation posted into the conversation — the row

  # the owner actually reads.

  defp report_content(job) do

    Repo.get_by!(Message, work_job_id: job.id, role: "assistant").content

  end

  defp delegation_owner(login) do

    {:ok, user} =

      Accounts.upsert_github_user(%{

        github_id: System.unique_integer([:positive]),

        github_login: login,

        github_avatar_url: "https://avatars.githubusercontent.com/u/1?v=4"

      })

    {:ok, conversation} = Conversations.ensure_conversation(user)

    {:ok, %{code: code}} =

      Machines.start_pairing(%{

        "name" => "report-box-#{login}",

        "tier" => "curated",

        "platform" => "linux-x64",

        "agent_version" => "0.1.0",

        "roots" => ["/tmp/openagents-work"]

      })

    {:ok, machine} = Machines.approve_pairing(user, code)

    %{user: user, conversation: conversation, machine: machine}

  end

  defp connect(machine_id, script) do

    start_supervised!({FakeController, machine_id: machine_id, script: script})

  end

  defp delegation_attributes(conversation, machine) do

    owner = Conversations.get_conversation_owner!(conversation)

    %{

      conversation_id: conversation.id,

      owner_visitor_id: owner.id,

      machine_id: machine.id,

      surface: "text",

      goal: "Delegate to claude on #{machine.name}: fix the failing test",

      kind: "delegation",

      delegation: %{

        "agent_id" => "claude",

        "machine_id" => machine.id,

        "machine_name" => machine.name,

        "prompt" => "fix the failing test",

        "cwd" => "/tmp/openagents-work",

        "timeout_ms" => 3_600_000

      },

      authority_snapshot: %{

        "machine_tier" => machine.tier,

        "roots" => machine.roots,

        "cwd" => "/tmp/openagents-work",

        "agent_id" => "claude",

        "machine_name" => machine.name

      },

      budget_snapshot: %{

        "wall_clock_ms" => 3_600_000,

        "maximum_prompt_bytes" => 8_000,

        "maximum_report_bytes" => 8_000

      }

    }

  end

  # The delegation runs in a supervised background process; the shared sandbox

  # makes its writes visible here.

  defp eventually(fun, attempts \\ 40) do

    cond do

      fun.() ->

        true

      attempts <= 0 ->

        false

      true ->

        Process.sleep(50)

        eventually(fun, attempts - 1)

    end

  end

end