Watch an agent work, see who owns the task, and know where the branch goes
Three things about running an agent from Pekan have been quietly unsatisfying, and they turn out to be the same story told three times: the app knew something useful and did not show it. A run was streaming and looked frozen. A run had started and the card looked idle. A branch was pushed and it was not clear what to do next. All three are fixed in this release.
Start with the live log. When Pekan launched Claude Code it asked for a single result document, and that is exactly what it got: nothing at all until the process finished, then everything at once. A run that took thirty-seven minutes showed No output received yet for thirty-seven minutes, then filled the window in one go. Nothing was wrong with the run, but there was no way to know that. Tracked Claude runs now ask for a real event stream instead, so the log fills in as the work happens.
That raised a second question, because a raw event stream is not pleasant reading. Codex has streamed one for a while and the viewer showed it verbatim: escaped source code, transport bookkeeping, and literal backslash-n where line breaks should be. The viewer now renders a transcript. Each line is either something the agent said, one tool call with the thing that call is about, a result or an error, or the final outcome. A file write shows the path, not the file. A command shows the command, not nine thousand characters of output. Session bookkeeping and rate-limit pings do not appear at all.
The exact bytes are never lost. Every log keeps both representations: the readable transcript, and the raw provider stream exactly as it was printed. A Formatted and Raw switch sits above the log, copy follows whichever one you are looking at, and download always gives you the raw stream, because a diagnostic log should never be a summary. Token usage, model identity, and the final result are still parsed from the raw stream, so cost reporting is unchanged. Reopening a finished run re-reads its raw log through the same formatter, so it looks the way it looked live. And when a run genuinely has nothing to show yet, the viewer says the provider is running and counts the elapsed time instead of implying it has stalled.
Second: ownership. Whether a task card showed an owner and a working indicator used to depend on whether the launched agent got around to calling the board tools, which is why one provider claimed its task promptly and another sat there anonymous. Pekan knows a run started the moment it spawns the process, so it now records ownership itself. An implementation run on an unassigned task assigns it, and the card lights up straight away, identically for every provider.
The rules around that are deliberately narrow. An existing owner is never silently replaced: if a task already belongs to you or to another agent, that assignment stays and the run simply shows up alongside it, so the board says who owns the work and who is currently running on it rather than quietly changing the answer. Read-only actions such as Research and Review never take ownership, because being asked for a code review is not the same as doing the task, though they do show the working indicator while they are active. A launch that fails to start leaves nothing behind. The working indicator is a heartbeat with a short expiry, so it disappears on its own if the app closes or a run is killed, and concurrent or retried runs on the same task each keep their own. The assignment itself stays after the run finishes, as a record of who did the work, and the run's first task comment now states what it did to ownership and why.
Third: delivered branches. A successful isolated run used to end at branch pushed, one commit ahead of base, which left you to work out what base meant and which branch this was supposed to return to. Pekan now records the intended target branch when it creates the worktree, alongside the base commit it already recorded. These are different facts and were easy to confuse: the base commit is where the run started, the target branch is where the work belongs, and your own checkout may have moved somewhere else entirely in the meantime.
With that recorded, a delivered worktree shows the source branch, the target branch, the commit range, the verification the agent reported, and where the work stands. Create pull request is the primary action, and it targets the branch captured at launch rather than whatever is checked out now. If a pull request already exists you get a link and its state, refreshable from the host, and a pull request that was closed without merging is reported as exactly that rather than as done. Where pull requests are not available, Copy local integration instructions gives you commands you can read: preconditions first, an explicit switch to the named target branch, and cherry-picks by full commit hash rather than a branch name that can move. A run with no recorded target, including one started from a detached HEAD, asks you which branch to use instead of guessing.
The safety boundary has not moved. Pekan pushes branches and it stops there. It does not merge, rebase, cherry-pick, force-push, or resolve conflicts on your behalf, and the local instructions are text to copy, never something the app runs for you.
Highlights
- Tracked Claude Code runs stream their progress, so the live log fills in during the run instead of all at once at the end.
- Provider output is rendered as a readable transcript: messages, one line per tool call, errors, and the final result.
- Large tool payloads and transport-only events stay out of the default view; the raw stream is kept in full.
- A Formatted and Raw switch controls the log, and download always gives you the exact raw provider output.
- An active run with nothing to show yet reports that it is waiting, with elapsed time, rather than looking stalled.
- Launching an implementation run assigns the task and shows the working indicator immediately, the same for every provider.
- An existing human or agent owner is kept, with the new run shown alongside rather than replacing them.
- Research, Review, and other read-only actions never take ownership of a task.
- A failed launch leaves no claim behind, and the working indicator clears on success, failure, cancellation, or app close.
- Isolated runs record the branch their work should return to, separately from the base commit they started from.
- A delivered branch offers Create pull request against that captured target, or copyable local instructions when a pull request is not available.
- Local instructions require a clean checkout, name the target branch explicitly, and cherry-pick by full commit hash.
- A merged pull request is shown as integrated; one closed without merging is not.
- Pekan still never merges, rebases, cherry-picks, or force-pushes for you.