The sidebar's `+N -N` only refreshed on three rare edges: the pane changing
directory, a command ending, and an agent turn ending. Edits made anywhere
else produced no signal at all, so the counts sat stale — a long agent turn
showed nothing until it finished minutes later, and a file edited in another
editor never registered until the user happened to run a command in the pane.
Two new triggers close the gap:
- Window activation re-probes every pane. Coming back to the window is the
only cue we get that the tree moved while the user was elsewhere, and the
sidebar lists every tab, so refreshing just the focused pane isn't enough.
- An agent's tool completions re-probe mid-turn. `AgentSessionState` gains an
`activity` counter because `ToolComplete` is deliberately a status no-op
during normal work, leaving status-watchers unable to see it.
Both go through a new throttled claim on `GitStatusCache` that drops triggers
instead of queueing them, so a busy agent or a window full of panes collapses
into one shell-out per repo per 1.5s rather than a `git` storm.
Also: fold the probe's two `rev-parse` calls into one (it now asks for
toplevel, git-dir and common-dir together), which makes `repo_home` a pure
function and unit-testable; and land probe results in the shared cache
independently of the pane entity, so a pane closed mid-probe can't wedge the
cwd-keyed in-flight claim for every other pane in that directory.
Resume-after-restart replayed a hardcoded per-agent command
(claude --resume <id>), dropping whatever flags the agent was
originally launched with (--dangerously-skip-permissions, --model).
The daemon's foreground poll already reads the agent's argv for
detection; keep it, stream it to the client inside AgentSessionState
(serde-default, wire-compatible both ways), persist it in the session
Leaf, and splice a conservatively-gated flag tail into the resume
command. The gate refuses anything that is not a plain flag-shaped
token sequence and falls back to the bare table command.
The Windows 133;C typed-command capture is forgeable by terminal
output, so it contributes identity only, never flags. Copilot gains a
resume entry (copilot --resume <id>, hooks already report its session
id) and Amp's threads continue verified to accept global flags.
Claude Code's EnterWorktree chdirs the agent without any shell cd, so the
sidebar's branch/diff line could not see the move on platforms without the
proc-cwd fallback. Forward the cwd field every Claude Code hook payload
already carries through the OSC 777 sentinel, keep it on the pane's agent
session state, and let it take precedence over the proc probe for the git
line. The claim is released on session-end (and when the agent leaves the
foreground), so an exited agent falls back to the pane's real directory.
ConPTY has no foreground process group, so the Unix process-table poll
(pgid -> argv) has no Windows equivalent and foreground_agent was a stub
returning None. Follow Warp's approach instead: the shell integration
captures the submitted command line at preexec and carries it
percent-encoded on the OSC 133;C mark; the daemon detects the agent from
that string.
- shell_integration: all four bodies (zsh/bash/fish/PowerShell) append
the submitted line to 133;C, truncated to 512 chars and escaped
(% ESC BEL CR NL). PowerShell guards the surrogate-splitting truncation
and wraps the emission in try/catch (EscapeDataString throws on lone
surrogates under .NET Framework / PS 5.1).
- pane: ShellState.command stores the capture (cleared on D only, so a
stray foreign A/B mid-command can't wipe the chip); on Windows
apply_signals feeds it through the new detect_from_command_with.
- cli_agent: detect_from_command_with tokenizes a typed command line
(quotes, & call operator, case-insensitive) and reuses the argv
detection; base_stem handles backslash paths and .exe/.cmd/.bat/.ps1.
- ForegroundProbes::agent is now Option<Option<CLIAgent>>: None means
'no process-table view' (native SSH, Windows) and is never applied,
fixing the 0.5s poll wiping event-branded agents on native-SSH panes.
Claude Code has no 'permission replied' hook, so after the user approved
a mid-turn permission prompt the dot stayed amber for the rest of the
turn. Install a PostToolUse hook mapped to a new tool-complete sentinel
event: the first tool that finishes after approval flips the state back
to Working (guarded on Waiting, so completions during normal work are a
no-op and a straggler can't overwrite Done). Same shape as Warp's
ToolComplete transition.
Old daemons drop the unknown event; existing installs surface as
Outdated in Settings -> Agents with an Update button, so the stale
'points at another tty7' copy is reworded.
* feat(agents): recognize CLI coding agents + show git branch in the sidebar
Observe (never wrap) third-party coding agents running in a pane — Claude
Code, Codex, Gemini CLI, Aider, Amp, OpenCode and ~10 more — and enrich the
UI around them, plus front each sidebar row with its git branch and diff.
Detection & identity
- Command-based detection over the foreground argv (launcher basename, and
interpreter-wrapped `node …/cli.js` / `npx …` forms), with user rules via
`agent_commands` in config. Brand avatars on the tab chip and sidebar row.
Rich status channel
- A per-pane state machine (idle / working / waiting-for-you / done) driven
by agent-reported events over an OSC 777 sentinel channel
(`tty7://cli-agent`, versioned JSON), sniffed daemon-side and streamed to
the client (DaemonMsg::AgentStatus).
- `tty7 agent-hook claude <event>` + a palette installer wire Claude Code's
lifecycle hooks up; the hook writes the sentinel to the controlling tty
(with an ancestor-tty fallback for detached hook processes).
- Avatar status dot: working (blue) / waiting (amber) / done (green); an
unread finished turn gets a crisp outer ring that clears on focus.
Notifications, resume, context feed
- "Needs your permission…" the moment an agent blocks; "finished after Ns"
per turn, honoring the notify policy (rich turns suppress the coarse exit).
- Session resume: restored panes re-launch their conversation
(`claude --resume …`), gated by `restore_agent_sessions` (default on).
- Palette commands send the current selection or the repo `git diff` to the
running agent as a ready-made prompt.
Sidebar git line
- New `terminal::git_status`: off-thread `git` probe (branch, or short sha
when detached; `git diff --numstat HEAD` line counts) with
GIT_OPTIONAL_LOCKS=0, refreshed on cwd change or command finish, dropped
on a stale cwd via a generation tag.
- Each row is avatar + title + `⎇ branch +N −M` (green/red), sized to
content; the redundant cwd/"Working…" lines and the aggregate rollup are
gone — the status dot and branch line carry it.
672 tests pass.
* fix(agents): repair CI and refresh the git line when an agent turn ends
- The live PTY detection test used `sh -c 'exec -a codex cat'`, but
`exec -a` is a bashism dash (Ubuntu's /bin/sh) rejects — spawn bash.
- cargo fmt over cli_agent.rs / view.rs / app.rs.
- An agent session is one long foreground command, so the back-to-prompt
edge never refreshed the sidebar's branch/diff line while the agent
worked — exactly when the working tree changes. poll_agent_status now
reports a turn ending (transition into Done) and the poll reprobes git
on that edge too.
---------
Co-authored-by: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com>
l0ng-ai
l0ng-ai