mirror of
https://github.com/l0ng-ai/tty7.git
synced 2026-10-06 08:02:04 +00:00
l0ng-ai
e38f450d1e
* feat(terminal): dock a message composer under agent panes A multi-line text box docked at the bottom of a pane whose foreground is a coding agent, for writing a prompt with the platform's own editing keys, mouse selection and an in-place IME, then handing it over whole. Toggle with Cmd+I (Ctrl+Shift+I off macOS) or "Toggle Message Composer" in the palette. - Docks below the grid instead of floating over it, so the agent reflows into the remaining rows and nothing it draws is hidden. - Enter sends, Shift+Enter inserts a newline, Esc hands focus back to the terminal without closing (so the next Esc still interrupts the agent). - A message is written as text, then Enter as a separate write after a short settle. Multi-line text goes as one bracketed paste; Codex is always pasted (its burst detector swallows the Enter otherwise); a leading `!` reaches Claude Code as its own key so it switches to shell mode. - Nothing is sent while the agent is waiting on a permission prompt or question; the box turns amber and keeps the message. - Writes queue per pane and stop if the agent exits mid-send, so an Enter can never land in the shell. - Pasted screenshots, copied files and dropped files reuse the terminal's existing path-pasting routes and land in the box when it has focus. - Drafts and the open state survive the view being rebuilt. Refs #842 * feat(terminal): give the composer a chat-box layout with attachments and / @ menus - A rounded, tinted frame whose hairline darkens on focus and on a file drag, a toolbar row with an attach button and a round send button that fills in once there is something to send. The key hints move into the send button's tooltip; the placeholder names the agent and what / and @ do. - Files become chips instead of words in the text: the attach button, a drop on the box, a pasted screenshot or copied file, and remote uploads all go through one paste_paths route that attaches while the box has focus. Backspace at the start of an empty caret removes the last chip. On send the paths follow the text as the shell words a drop would have typed. - `/` at the start of the message opens the agent's built-in commands (Claude Code, Codex, Gemini) plus Claude's custom commands from .claude/commands; `@` at the start of any word opens files from the pane's project, reusing the quick-open walk so it works on remote hosts too, spelled relative to the pane's directory. Up/Down move, Enter/Tab pick, Esc dismisses. - Shift+Tab is passed through to the agent to cycle its permission mode. - Enter with nothing to send no longer sends a bare Enter. No model picker, mode label or context meter: tty7 has no source for them that would stay true, and /model is one keystroke away in the menu. * feat(terminal): lay the composer over the agent's own input, with its toolbar The composer now stands in for the agent's input instead of sitting under it, so the pane has one input rather than two. - For Claude Code, Codex and Gemini the box is laid over the input area it finds on the grid (Claude's ruled prompt block and the status rows under it, Codex's `›` line, Gemini's framed prompt), painted in the grid's background. When the agent puts something else there — a permission prompt, a picker — the area stops reading as an input; after a 250ms grace the box steps aside and the keyboard goes to the TUI, and both come back with the input. Other agents keep the docked layout. - Over the input, Esc is the agent's (it interrupts), Ctrl+C clears the box or reaches the agent when the box is empty, and text typed at the grid lands in the box. - The toolbar: permission mode (read off the status row the box covers, falling back to the hooks' permission_mode; click or Shift+Tab to cycle), model (click opens Claude's picker), Think (Claude's thinking toggle), and a context ring. Labels come only from what the agent reported. - Claude hooks now carry an AgentReadout — permission_mode from the hook payload, the model and context size of the last main-thread reply from the transcript, the context window (1M for a [1m] model or past 200k), and alwaysThinkingEnabled — worked out in the hook so remote panes get it too. - Visual pass against the design: 13.5px text with the design's padding (the input's own padding subtracted), a 40px toolbar of 28px buttons, a dark round send button, image chips with their own glyph. * feat(terminal): replace the composer's Think toggle with an effort picker The toolbar's thinking toggle is gone; reasoning effort is what the agent actually exposes as a per-session dial. The button shows the level Claude Code is set to (CLAUDE_CODE_EFFORT_LEVEL, else effortLevel from its settings, reported by the hook) and opens a menu of low / medium / high / xhigh / max. Picking one sends the agent's own /effort command, and the label follows the pick until the next hook event confirms it. * feat(terminal): open the composer's model and effort lists over their buttons, and seat the box where the agent's input starts * style(terminal): align the composer with the design: bottom inset, hairline ring, effort label * style(ui): draw the sidebar dividers as one-device-pixel hairlines * fix(terminal): keep the composer's contents still when its ring thickens * fix(terminal): let a click outside the composer keep the keyboard * fix(terminal): a click beside the covering composer leaves it, as one on the grid does * fix(terminal): paint the composer's lists over its ring, and give Effort its chevron * fix(terminal): show the effort level alone, close toolbar lists on an outside click, read per-model effort * fix(core): take the effort level Claude reports in the hook payload * feat(core): send a Claude turn's context size once its transcript catches up * Revert "feat(core): send a Claude turn's context size once its transcript catches up" This reverts commit 3544bc6b172901977749c6d6041650ae3795be37. * refactor(terminal): drop the composer's context gauge until there is an exact source for it * fix(terminal): a paste at the grid goes into the composer covering the input With the box laid over the agent's input, typing at the grid already went into the box, but a paste (Cmd+V, a dropped or copied file) still went to the pty — into the agent's own input, out of sight under the box, where the next Enter would send it unseen. A paste now lands in the box the way typing does, files as attachments, and takes the keyboard with it. * fix(terminal): cover the agent's input from its top rule at any pane height The covering layer measured its height up from the pane's bottom edge in whole rows plus the padding, but the grid's rows start at the top: whatever part of a row the pane's height leaves over sits between the last row and the padding. At most heights that left the top of the covered area — Claude Code's upper rule — showing above the box. The grid now records that leftover and the layer counts it in. * fix(core): report Claude's model and effort only when they are this turn's The hook filled in the model from the transcript's last reply on every event. That reply is the previous turn's: after a `/model`, or a resume under another `--model` (a resumed session's SessionStart names none), the toolbar showed the old model — and at `Stop` too, since Claude Code runs the hook before the turn's reply is always on disk. The model now comes from SessionStart, or at Stop from the reply that turn wrote: found after the prompt the payload names, matching the words it carries, waited for briefly. Nothing exact means nothing reported. Effort likewise: the settings fallback only runs for a model the event names (it may be set per model), and a turn that ends without a level ran on a model that takes none, which the toolbar now shows as no level rather than the settings' general one. A level picked from the toolbar gives way to the agent's report once that changes, as a picked model does. * fix(terminal): offer Fable in the composer's model list Claude Code's `/model` list has Fable between Opus and Sonnet, and `/model fable` takes it by that alias, but the toolbar's list left it out: it could not be picked there, and a session running it had no row checked. * fix(terminal): a toolbar pick holds only until the agent's next finished turn A model or effort picked from the toolbar was shown until the agent reported a different value. When the pick did not take — Claude asks before switching a cached conversation's model, and "No, go back" keeps the old one — the report never changed and the toolbar showed the refused model for good; after the agent quit and a new session started on the model the pick was made from, the stale pick came back. A pick now stands until the next finished turn, which reports what the agent actually ran on, and is dropped when the agent session changes. * fix(core): keep agent hook sequences short A hook reports to the pane by writing an OSC 777 sequence to the tty the agent draws on. macOS does not keep a tty write whole: under output pressure the kernel parks the writer mid-sequence and lets the other writer in, so the agent's redraw lands inside our sequence, the OSC breaks, and the rest of the JSON is printed on screen. The longer the sequence, the likelier that is. The prompt a turn starts with was the bulk of it on `prompt-submit` (up to 200 characters, three bytes each for CJK), and nothing reads it any more since the conversation outline went away. Stop sending it, and cap the agent's message at a status line's worth. * fix(core): hand agent hook reports to the daemon over its socket An agent hook reported by writing an OSC 777 sequence to the tty the agent draws on. A tty write is not atomic: on macOS the kernel parks a writer whenever the output queue is over its high-water mark, which is exactly when the agent is busy redrawing, and lets the other writer in. The agent's output then lands inside our sequence, the OSC breaks, and the rest of the JSON is printed on screen. A pty test with a busy writer next to a small one splits even 100-byte writes, at arbitrary offsets, so no size keeps the sequence whole. The hook now sends the same JSON to the daemon that owns its pane (`$TTY7_PANE`, over the pane socket `$TTY7_CONFIG_DIR` leads to), which applies it exactly as if its reader had found it in the output. The pane id comes from the environment, which a detached tmux server or the like carries out of the pane, so the daemon applies a report only from a process that runs under the pane's shell. Anything else — no daemon, one that predates the message, a refusal — falls back to the tty as before, which is still how a hook with no daemon beside it reports. * fix(terminal): offer /effort in the composer's command menu for Claude The toolbar's effort picker types `/effort`, but the `/` menu did not list it. Bring the list in line with current Claude Code while at it: `/usage` replaces `/cost`, which is now only its alias, `/rewind` joins, and `/agents`, which Claude Code has removed, goes. * fix(terminal): step aside for Codex's own lists instead of covering them Codex marks the selected row of its lists -- the approval prompt, /model, /permissions, the hook review and the update offer at launch -- with the same `›` that starts its input line. The composer took that row for the input and laid the box over the list, hiding the options the user had to pick from. A `›` row that is a numbered option with sibling options around it is now read as a list, and the box steps aside. * fix(terminal): offer Codex's /permissions, not the retired /approvals Current Codex no longer knows /approvals; the command that chooses what it may do without asking is /permissions. Also offer /resume. * fix(core): install Codex hooks into CODEX_HOME when it is set Codex reads hooks.json from its home, which CODEX_HOME moves. tty7 always wrote and checked ~/.codex/hooks.json, so for such a user the hooks it installed never ran, and the state it reported described a file Codex does not read. Local-only, like the other config-dir overrides. * fix(core): find the pane a Codex hook reports on from the report itself Codex runs its hooks in its app-server, one background process every Codex session on the machine talks to. The first session starts it, and it outlives that session, detached. Its hooks therefore carry the first session's $TTY7_PANE and run under that pane's shell only while that session lasts. Once it ended, the daemon refused every Codex report as coming from outside the pane -- and the tty fallback has no terminal in a detached process -- so a Codex pane never showed working, waiting or done. While the first session was still running, a second pane's reports were taken as the first pane's. A Codex report is now matched to its pane by what it says: the pane that already reported its session, else the one pane running Codex in its directory (the one yet to report a session, and the named pane on a tie). Other agents' reports are unchanged. * fix(core): install Gemini hooks under GEMINI_CLI_HOME when it is set Gemini CLI roots its user-level .gemini directory at GEMINI_CLI_HOME in place of the home directory. tty7 always wrote and checked ~/.gemini/settings.json, so for such a user the hooks it installed never ran, and the state it reported described a file Gemini does not read. Local-only, like the other config-dir overrides. * fix(terminal): find Gemini's input in the shaded block it draws now Gemini CLI no longer frames its input in a rounded box: it shades the prompt line between a row of lower half blocks and a row of upper half blocks, and with shading off it draws a rule over the prompt instead. The composer looked only for the old frame, so over a current Gemini it stayed stepped aside for good and never covered the input. A message already sent is shaded the same way in the transcript, so the block counts only with nothing but the footer under it; a permission prompt or a list in the input's place leaves the last message above more than that, and the box steps aside for it. The old frame is still found for older versions, and the shell, YOLO and history-search marks count as a prompt as well as `>`. * fix(terminal): give Gemini time to read a paste before pressing Enter Gemini CLI takes an Enter that comes within 40ms of a bracketed paste as a line break. It starts that window once it has read the whole paste, so the 50ms the composer left between the paste and the Enter was not enough for a long message: a 41-line message sat in Gemini's input as "[Pasted Text: 41 lines]" plus an empty line, hidden under the box, and was never sent. Gemini now waits as long after a paste as Copilot does; a 400-line, 32KB message goes through whole and is submitted once. * fix(terminal): hand Gemini its attachments and mentions so it reads them Three things kept files from reaching a Gemini turn from the composer: - Attachments went after the text as shell words. Gemini turns a drop into @ mentions itself, but only a paste that is nothing but paths; after the message's text a path is just words, and the model never saw the file. Gemini now gets its attachments as the mentions it would have made. - A mention picked from the @ menu was spelled raw. Gemini ends a mention at the first unescaped space, so "my notes.txt" became "@my". Mentions for Gemini are escaped the way its own escapePath does it. - With the caret at the end of an @ word Gemini lists matching files, and Enter takes the list's pick instead of sending, so a message closed by a mention - every message with an attachment - sat in the input under the box, unsent. A message with a mention now ends in a space, which closes the list; slash commands are left alone. * fix(terminal): offer Gemini's current commands in the composer's menu Gemini CLI now names its session browser /resume, with /chat kept as an alias, and /clear starts a new session rather than only clearing the screen. Offer /resume under its own name, say what /clear does now, and add /model and /init, which the menu left out. * fix(terminal): paste messages to Gemini instead of typing them Gemini CLI judges each key of a typed burst against its input as it was before the burst, so to it the input is still empty at every key. A "?" anywhere in a typed line is taken for the key that opens its shortcuts on an empty input and dropped ("what? yes" arrived as "what yes"), and a "!" for the one that switches it into shell mode, which also clears what came before it: "hi! there" became a shell command " there", one Enter away from running. Gemini now gets every message as a bracketed paste, like Codex, with a leading "!" still sent as a key of its own - as for Claude Code - so a message that starts with one keeps opening shell mode. * fix(terminal): spell a mention with a space the way Claude and Codex read it A file picked from the composer's @ menu went in raw for Claude Code and Codex, so "my notes.md" came out as "@my notes.md": - Claude Code ends a bare mention at the first whitespace, so it looked for "my" and the file never reached the turn. A path with a space now goes in double quotes, @"my notes.md", the form Claude's own list puts in and its parser reads back as one file. - Codex hands mentions to the model as plain text, and its own list puts in the path alone: without the @, in double quotes when it has a space in it. The composer now does the same. Checked for real: Claude 2.1.286 with no tools answers from @"my notes.md" and not from @my notes.md or @my\ notes.md; Codex 0.158's list inserts "my notes.md". Attachments are unchanged; both agents read one with a space in its path. * fix(core): name tty7's Gemini hooks so Gemini shows "tty7" while they run While a hook runs Gemini CLI shows "Executing Hook: <name>" above its input, and a hook without a name is shown by its whole command - the quoted path of the tty7 binary and its arguments. tty7's Gemini entries now carry "name": "tty7". An install from before reads as outdated - its hooks' names are checked along with their commands - so the launch-time refresh and the settings page's Update rewrite it in place, one entry per event as before. Other agents' entries get no name and are judged as before. * fix(core): show no effort level for a Claude model that takes none A new Claude session names its model but not its effort level, so the hook fell back to the settings' level - and a session started on Haiku showed "High" until its first turn ended. The hook now checks Claude Code's own model catalog (its cache, read only) first: a model it lists without effort options is reported with an empty level. A model it does not list, or no catalog at all, falls back to the settings as before. * fix(terminal): paste messages to OpenCode and Amp instead of typing them OpenCode reads a burst of typed keys against the input as it was before the burst, the way Gemini does: the `!` in "PONG! ok" switched it into shell mode and the rest of the line ran as a shell command. Amp takes a typed leading `?` for its shortcuts key and drops it, and a typed leading `/` opens its command palette while the rest of the burst lands in the input underneath, so Enter ran whatever the palette listed first. Both now get every message as one bracketed paste, which each reads intact and sends on the Enter that follows. A leading `!` still reaches OpenCode as a key of its own, the only way it switches into shell mode; Amp reads its `$` shell prefix off a paste. * fix(terminal): stand the docked composer as far in from the bottom as from the sides Docked under the grid, the box sits inside the pane's padding, and only the side inset took it off: the box stood 20px up from the pane's bottom and 16px in from its sides, where it covers an agent's input 16px from all three. * fix(terminal): offer OpenCode's commands in the composer's menu OpenCode takes slash commands typed at its input, pasted ones included, but the composer's `/` menu listed none for it and its placeholder left out the commands hint. List the ones its own menu opens with, in its words. Amp keeps an empty list: its `/` opens a command palette that a message cannot drive. * fix(terminal): hand OpenCode and Amp their attachments as pastes of their own Both attach an image only from a paste that is nothing but its path; a path after the message's text stays words, so an image attached in the composer never reached the model. They now get the text, then each path as a paste by itself after a typed space, and Enter once the last one has had time to land. OpenCode shows the file as a part of the message and Amp lists it under Images, as a drop onto their own input would. * fix(terminal): don't answer pixel-size queries from a replayed pane A reattach replays the pane's ring through the grid with query replies muted, but the mute list missed `TextAreaSizeRequest`: alacritty hands `CSI 14t` to the listener as its own event (the view owns the pixel size) rather than as a `PtyWrite`. Every `CSI 14t` a TUI had sent was answered again on each app restart, and the `CSI 4;h;w t` replies landed on whatever reads the pane now — at a shell prompt, after the TUI that asked had quit, zsh printed them as `;840;873t;840;873t...`. Mute it with the other replies; live queries are still answered. * fix(core): don't let a hook wait on a terminal whose pane has gone An agent's session-end hook that falls back to the tty after its pane closed opened the terminal device blocking. With the pty's other end gone that open waits for a carrier that never comes, and on macOS it waits holding the lock every lookup under /dev needs: the hook never exits, the agent cannot finish exiting, and every new shell, ps and tty on the machine hangs behind them until the hook is killed. Open the device without waiting, then switch it back to blocking writes so a busy terminal still gets the whole sequence; a terminal with no other end fails the write at once. * fix(terminal): paste messages to Copilot instead of typing them Typed into Copilot's empty input, a leading `?` is the key that opens its help: "?why" went out as "why". Paste every message, as for Codex and Gemini. Copilot still reads a pasted leading `!` as its shell mode, and already got the longer wait before Enter that a paste needs. * fix(terminal): speak to Qwen Code the way Gemini is spoken to Qwen Code is a fork of Gemini CLI and kept its input, but the composer treated it as an agent with none of Gemini's traps: - a typed leading `?` opened its shortcuts and was lost; - a message closing on an `@` mention sat in the input, its Enter taken by the file list; - a mention or attachment with a space in its path went out as words it cannot read back. Give it Gemini's handling: pasted, with the shell-mode `!` as a key of its own, a space after a closing mention, the longer wait before Enter, and attachments and `@` picks spelled with Gemini's escaping, plus the comma Qwen escapes too. * fix(terminal): leave Copilot's file list behind before pressing Enter With the caret at the end of an `@` word Copilot lists matching files, and Enter takes the list's pick instead of sending, so a message that closed on a mention (one picked from the composer's own `@` menu ends that way) sat in Copilot's input unsent. End such a message with a space, as for Gemini. * fix(terminal): hand CodeBuddy a leading `!` as a key of its own CodeBuddy switches into bash mode only on a `!` typed into its empty input by itself, as Claude Code does. Arriving in one burst with the rest of the line it is just a character, so "!git status" went to the model as a request to run the command, behind a permission prompt. * fix(terminal): paste messages to Kimi Code so they are sent Kimi Code takes keys arriving faster than anyone types for an unbracketed paste, and the Enter right behind a typed line for one of its newlines: a one-line message from the composer sat in Kimi's input with an empty line under it, never sent. Paste every message instead. Kimi knows a bracketed paste for one, sends on the Enter after it at once, and still reads a pasted leading `!`, `?` or `/` as typed. * fix(terminal): spell a mention with a space the way Kimi Code does Kimi Code's own `@` list puts in a path with a space as `@"my notes.md"`, the way Claude Code spells it. The composer's menu put in `@my notes.md`, which Kimi reads as a mention of `my` followed by a word. * fix(terminal): offer Copilot's, Qwen Code's, CodeBuddy's and Kimi Code's commands All four take typed slash commands, but the composer knew none of them: `/` opened no menu and the placeholder offered only `@` files. List each one's everyday commands as its installed version names them: Copilot CLI 1.0, Qwen Code 0.24, CodeBuddy Code 2.161 and Kimi Code 2.1, which has `/new` rather than `/clear` and `/permission` in the singular. * fix(terminal): hand Copilot and CodeBuddy their attachments as mentions Copilot and CodeBuddy attach a file only from an `@` mention, and a path after the message's text is just words to them: an attached image reached neither model, which had to go and read it with a tool, behind a prompt. Send each attachment as an `@` mention instead, which both attach to the turn, an image as an image. Neither reads a mention back past a space, so a path with one still goes as quoted words. * fix(core): import Pi's extension types from its current package Pi moved from @mariozechner/pi-coding-agent to @earendil-works/pi-coding-agent. Current Pi resolves both names for extensions, and the bridge's import is type-only, so it is erased before an older Pi that knows only the old name loads it. A bridge already written with the old name reads as stale and launch's refresh rewrites it. * fix(core): keep Pi and Oh My Pi panes working through retries and approvals agent_end closes every attempt, so a run Pi retries after a provider error read as done while it was still retrying. The bridge now takes Pi's agent_settled as the end of a run when the build sends it, and Oh My Pi's auto_retry_start puts the pane back to working. Oh My Pi asks before running a tool through tool_approval_requested and tool_approval_resolved, not Pi's UI-prompt pair, so its pane said working while the approval dialog waited. Those now report waiting and restore the turn. * fix(core): take Prime Agent's hook reports from its background daemon Prime Agent runs each session in a detached daemon, started by the first session and outliving it, and the daemon runs tty7's bridge there with the environment of the TUI that asked for the session. The report names the right pane, but its process never runs under that pane's shell, so the daemon turned every one away and a Prime Agent pane never left idle. A report about Prime Agent is now taken by the pane it names when that pane is running Prime Agent. * fix(terminal): lay the composer over Pi's own input The box docked under Pi's pane, so Pi's own ruled editor and its status rows stayed on screen above it: two inputs. Pi now gets the covering box Claude, Codex and Gemini have. Its editor is the lowest pair of full-width rules — the upper one carries the spinner while a turn runs — with the directory and usage rows under it, and the box covers from the upper rule down. Pi's selectors take the editor's place between the same rules but open on a blank row (or, for /settings, on a `>` search line) and run on for several, so the box steps aside for them and comes back once they close. * fix(terminal): offer Pi's, Oh My Pi's, Prime Agent's and Grok Build's commands All four take typed slash commands, but the composer knew none of them: `/` opened no menu and the placeholder offered only `@` files. List each one's everyday commands as its installed version names them — Pi 0.99, Oh My Pi 18.4 (`/exit`, `/retry`, `/todo`), Prime Agent 0.9 (`/effort` rather than Pi's `/thinking`) and Grok Build 1.0 (`/mcps`, `/recap`). * fix(terminal): lay the composer over Oh My Pi's own input The box docked under Oh My Pi's pane, so its own input stayed on screen above the box. Oh My Pi now gets the covering box too. In its default status-band shape, and in the rounded box, the input's first line opens with `╰─ ` under the status line, and the box covers from that line down; a dialog frame closes with `╰──…╯` and a tool approval or picker takes the input's place, so the box steps aside for those. Its Pi and Claude Code shapes are ruled like Pi's input and found the same way. That input is two rows, where the box is about five, so laid over it the box hid the last lines of the reply. For Oh My Pi the grid now gives up the rows the box needs beyond the input, measured off the box as drawn empty, and the agent draws its input that much higher. * fix(terminal): lay the composer over Prime Agent's own input The box docked under Prime Agent's pane, so its own shaded input block stayed on screen above the box. Prime Agent now gets the covering box too: its input is a blank row, the ` >` prompt line with any further lines indented under it, and another blank row, right over the footer that ends the screen. The model picker draws its own ` >` search line between rules, away from the footer, so the box steps aside for it. The block and footer are a row shorter than the box, which cut the hint line above it in half; the grid makes room for that row as it does for Oh My Pi. * fix(terminal): lay the composer over Grok Build's own input The box docked under Grok Build's pane, so its own framed input stayed on screen above the box. Grok Build now gets the covering box too: its input is the rounded frame whose first line opens with `❯`, with the key hints under it. Its `/` and `/model` lists open over the frame between two rules, and its dialogs are drawn across the frame's top edge; the box steps aside for both, since they take the keys the box would send. Grok Build keeps a command whose list was dismissed in its input, where under the box nobody sees it and the next message was typed on after it: `/modelReply …`. With text left there, the box now clears it with Ctrl+U before sending. * fix(terminal): spell mentions the way Pi and its forks read them Pi, Oh My Pi and Prime Agent end a bare `@` mention at the first space, and their own `@` lists put a path with one in double quotes, `@"my notes.md"`; the composer put it in bare, so the mention named a file that does not exist. Grok Build's list puts the path in as it is, which the composer already did. Oh My Pi reads a mentioned file — an image included — into the turn itself, where a path in the message is just words for the model to go and read, so its attachments now go as mentions. * fix(terminal): send Oh My Pi, Grok Build and Prime Agent messages that end in a mention Oh My Pi's and Grok Build's `@` lists open on a mention at the caret and take the Enter that follows, so a message whose attachments or mention closed it sat in their input, under the box, unsent. Like Gemini's and Copilot's, their messages with an `@` now go with a space after them. Prime Agent's list opens as a typed mention is typed and stays open past the space after it: "read @a.txt " went out as "read @a.txt .git/". A paste it reads whole, `!` and `/` included, so its messages are pasted. * fix(terminal): stop a Grok Build turn with its own interrupt key Esc in the box covering an agent's input is that agent's Esc, the key that stops a turn. Grok Build's Esc leaves a running turn running — its stop key is Ctrl+C — and the daemon, reading any Esc during a turn as an interrupt, then called the pane done while Grok still worked. The box now sends Grok Build Ctrl+C, and the daemon no longer counts an Esc as stopping a Grok Build turn. * fix(core): don't start a turn from a notification's waiting status Before an agent's first hook, a desktop notification marks its pane waiting. Crush raises one after every turn ("Agent's turn completed"), and its only hook, PreToolUse, is reported as a finished tool, which moves a waiting pane back to working: from the first tool of a session on, the pane read as working for good, as Crush has no Stop to end it. A status set by a notification now gives way to idle when the first hook report arrives, so the report only records the session and its activity. * fix(terminal): take only a hook's word that the agent is asking The box stands aside and sends nothing while the pane's agent is waiting, since whatever it sent would answer the question on screen. For an agent without hooks — Amp, or Crush before its first tool — the pane is marked waiting by any desktop notification, "Agent is ready" at the end of a turn among them, and it stays marked. From the first finished turn on the box stood aside for good, and messages went into the agent's own input instead. Waiting now holds the box back only when hooks reported it. Those agents' own dialogs take their input's place on screen, and the box steps aside for them off the screen as for any other. * fix(terminal): offer Goose's commands in the composer's menu Goose takes typed slash commands — /model, /mode, /compact, /clear and the rest of what its /help lists — but the box's `/` menu was empty for it. It now lists them, as Goose 1.52 names them. * fix(terminal): stop a Crush turn with the two Escs it asks for Crush takes a first Esc during a turn as a question — "esc press again to cancel", in its key help — and stops only on a second one. Over its input the box's Esc sent one, the question sat in the help under the box where nobody read it, and the turn ran on. For Crush the box now sends both, as separate writes: in one read the two are a single key to it. * fix(terminal): lay the composer over Crush's, Goose's and Amp's own input The box docked under these agents' panes, so their own inputs stayed on screen above it: two inputs. They now get the covering box too. - Crush's editor opens on its `> ` prompt (`!` in yolo mode, `:::` while the chat has the keys) with each further line on `:::`, over a blank row and its key help. Its dialogs — the command palette, the model and session lists, a permission request — are framed over the screen with the editor left standing under them, and take the keys, so with a frame on screen the box steps aside. - Goose prints its `> ` prompt under its context gauge, as the last thing on the screen, wherever its output ended. A turn's spinner and output, and a tool approval, are printed under the line sent, and the box steps aside for them until the next gauge and prompt. Its input is two rows where the box is about five, so the grid gives up the rest, as it does for Oh My Pi. - Amp frames its input at the bottom of the screen, its mode in the top edge and the directory in the bottom one. Its palette and file list open framed and indented over the screen, and a notice in the input's place (out of credits) is a frame with nothing in its bottom edge; the box steps aside for both. Text typed into one of these inputs before the box was opened over it stays there, unseen, and the next message would run on after it. With text left there the box now empties it first, a line at a time with Ctrl+U and Backspace, as it empties Grok Build's with Ctrl+U. * test(core): keep the closed-terminal write test from racing other tests' children `a_terminal_with_its_other_end_gone_fails_the_write_at_once` failed about one run in three alongside the other hook tests (never on its own): its pty came from `openpty`, whose descriptors are inherited, and the Qoder, CodeBuddy and Crush config tests spawn children on threads of their own. A child that took a copy of the pane's end kept it open after the test closed it, and the write went through. Open both ends close-on-exec from the start, and since a child forked a moment earlier still holds a copy until it gets to exec, retry a write that went through after a short pause; every attempt must still return within the timeout, which is what the test is for. 50 runs of the hook tests in parallel now pass, where 13 of 40 failed before. * fix(terminal): lay the composer over Copilot's, Qwen Code's, CodeBuddy's, Kimi Code's and OpenCode's own input The box docked under these agents' panes, so their own inputs stayed on screen above it: two inputs. They now get the covering box too. - Copilot, Qwen Code and CodeBuddy rule their input off top and bottom, the prompt (`❯`; `>`, `*` or `!`; `>`) on the line right under the upper rule and the status rows under the lower one. Their approvals and pickers come framed or between rules of their own with the question on the first line, and their `/` and `@` lists open under the lower rule or, Copilot's, right over the upper one; the box steps aside for them. Qwen Code is drawn as Gemini's ruled input once was, but Gemini's looser test takes the `> model` row of Qwen Code's own `/` list for the prompt, so it gets the stricter one. - With true colour Copilot shades its input instead — a `╻▄▄▄` and a `╹▀▀▀` edge around lines on a `┃` bar — and draws its lists shaded over it, the selected row opening with `❯ /`; a sent message has the time at its end. - Kimi Code frames its input over its model line and context gauge. Its lists open under the frame, its approvals take the frame's place, and its welcome banner is a frame far up the screen. - OpenCode draws its input on a bar closed by a `╹▀▀▀` edge over its key hints, in the middle of its home screen and at the bottom of a session. Its lists open on the same bar, each row closed by a `┃` at its right, and a permission request takes the input's place with no edge. Text typed into one of these inputs before the box was laid over it is emptied first, a line at a time with Ctrl+U and Backspace, placeholders and offered suggestions not counted. CodeBuddy takes keys that arrive together for a paste and does none of them, so it is sent them one at a time. * fix(terminal): take Qwen Code and CodeBuddy out of shell mode before a plain message A `!` message is a shell command to Qwen Code and CodeBuddy, and both stay in their shell mode after it has run, their prompt a `!`, until Esc takes them out. The next message from the box ran as a command too (`bash: ?: command not found`), and a second `!` message toggled the mode off and went to the model. With the box over the input, the prompt says which mode it is in: a plain message now leaves shell mode with Esc first, and a `!` message sent in it drops the `!` that would toggle it off. CodeBuddy's `!` prompt counts as its input, so the box no longer steps aside for it. * fix(terminal): paint the layer under the covering composer in the agent's own background The layer laid over an agent's input was painted in the theme's background. Grok Build, OpenCode and other agents that paint the screen in a colour of their own were left with a strip of the theme's colour around the box — a light band under Grok Build's dark screen. The layer now takes the colour the agent paints the row over its input in (the one most of its cells have), over the grid's columns only; the pane's padding around them keeps the theme's. An agent that leaves the terminal's own background, as Claude Code, Codex, Kimi Code and Copilot do, keeps the layer as it was. The box's own fill was a faint tint of the text colour, which showed whatever was under it: on Grok Build's dark layer the box went dark and its text could not be read. It is now that tint laid over the theme's background, the same colour as before on the theme's own background. * fix(terminal): lay the composer over Qoder's own input and speak to it the way Gemini is spoken to Qoder (both the global and the CN build) docked the box under its pane, its own input left standing above it: two inputs. - Its input sits between the last two full-width rules, opening with ` > ` (` * ` in YOLO mode, ` ! ` in shell mode), with only its model line under the lower rule. Over the upper rule its mode line has a rule of its own, with the `? for shortcuts` hint above it; the box covers those too. Its `/` and `@` lists open under the lower rule with the selected row opening with `❯`, and its trust and sign-in prompts, `/model` and `/help` open under a single rule with no prompt; the box steps aside for them. - It is a Gemini CLI fork and kept that input: keys in a burst are read against the input before the burst (`echo hi` typed came out `echo hiecho hi`), a typed leading `?` opens its shortcuts, the Enter right behind a paste is a newline, its `@` list takes an Enter that comes right after a mention, and its list spells a path with a space `@my\ notes.md`. It now gets Gemini's handling of all of these. - Like Qwen Code it stays in shell mode after a `!` command; a plain message leaves it with Esc first. Text left in its input is cleared with Ctrl+U and Backspace. Its `/` menu offers its current commands. * fix(terminal): pick OpenCode's mentions from its own @ list so the files are attached OpenCode attaches a file to a message only when it was picked from its own `@` list (or handed over by an editor); the text of a mention is just words to it. `@my notes.md` from the box, and `@plain.md` as well, reached the model as text, which went looking for the file with its tools — and the one with a space it had to find by globbing. A message for OpenCode in a local pane is now cut at its `@` mentions of paths that exist under the pane's directory (the longest run of up to four words that names one), and each is sent the way a pick is made: a typed `@`, the path pasted as the query with its spaces left out (a space would close the list), and Enter once the list has had time to search. OpenCode then shows `File my notes.md` under the message. A space typed after it closes a list that found nothing, so the Enter that sends is not taken by it. An `@` that names nothing, commands and shell lines go as before. * fix(terminal): cover Gemini's mode line and shortcuts hint along with its input Gemini CLI 0.62 draws a mode line ("Shift+Tab to accept edits", "shell mode enabled") over its input, with a rule of its own over it and the `? for shortcuts` hint above that. The box covered the input from its shaded block (or the rule right over its prompt) down, so the hint, the rule and the mode line were left standing over the box. The box now covers from the rule over that mode line, and from the hint when it is there — the way it already does for Qoder, which draws the same block; the two share the lookup. An input without a mode line over it is covered from its own top as before. * style(core): settle the clippy warnings the interrupt-key reader brought in `is_interrupt_key` is only asked by the tests since the Grok Build change went through `interrupts`, and two `let … else { return None }` read the kitty-protocol key; the first is test-only now and the other two use `?`. * fix(terminal): a screenshot pasted into the composer becomes an attachment * fix(terminal): keep the composer's reserved rows, pastes and screen scans in line with the box Scrolling back no longer resizes the pane, outside pastes land in the box when it covers the input, the screen is scanned only while the box is open, the command scan stops 8 directories deep, effort labels capitalise by character, and two doc comments sit on their own items again. * fix(core): route Codex reports past /new and codex -C, trust agent_settled only once seen A session /new started goes to the Codex pane that had one; a report from a directory no pane runs Codex in is matched among every Codex pane instead of falling back to the app-server's. The Pi bridge no longer reads a returned function from on() as proof agent_settled will come, and the Stop hook re-reads the transcript only once it has grown. * refactor: carry a session's source on AgentEvent and tidy the review fixes The Codex router reads source off the parsed event instead of parsing the hook body again. The command scan reads each real directory once rather than capping depth, labels capitalise through one helper (alias_label no longer slices bytes), the live input rows are set where Covering is decided, and the transcript is opened once per poll. * fix(terminal): read Claude's custom commands through Host The scan reached std::fs directly, which the host-boundary check rejects; it now walks the pane's host, joining and canonicalizing through it, and its test covers a link back up the commands tree.
