- Clean up re-reads what is still in Done after the dialog, and asks again
if it would now end something the dialog never named.
- `tty7 -m … task add --cwd` takes only a full path on that machine.
- A tab still connecting at startup holds the column its agent last reported
in the machine tree instead of flashing into Review.
- A run records only its own agent's session id, never a neighbour's.
- A question is cleared when its session starts, ends or is interrupted.
- task_put makes room and inserts in one commit.
- Runs whose agent was never handed the prompt (`Run::bare`) read as
waiting on the user, not Running.
- A prompt starting with `-` goes after `--` or is glued to its flag.
- Build cards once per frame; stat worktrees at most every 5s.
- `~bob` is not the user's home; a reply whose tab closed says so;
stated_title gets its doc back; reuse tray::urgency.
Review fixes for the Board.
Keys to the right agent
- A card resolves the exact pane that speaks for its tab; Allow, Pause, reply,
output and note_runs no longer hit the first agent pane of a split.
- Allow (button, menu, drag, key) carries the prompt it was drawn with and only
sends Enter if the agent still waits on that same permission prompt.
- A reply is refused while a prompt is pending; drafts are kept per card.
Work is not destroyed silently
- Clean up confirms when a pane is still running something or extra tabs in the
worktree would close; deletes the task first, closes tabs, waits for panes,
then removes the worktree; the toast names the refs/tty7/trash ref.
Clean up all confirms with the count, folded cards included.
- The composer keeps a draft on Esc / scrim / close; a long one-line task keeps
its full text as the prompt; branch names are checked inline and a taken
name says which one will be used; typed paths are checked on the host.
State
- Done records where each run stood (tab, session, turns, busy), so a busy card
dragged to Done stays there and a relaunched agent leaves Done.
- Worktree starts show "Starting…", can't be started twice, and append the run
to the current task instead of a stale copy.
- Pending task edits survive a resync and are replayed.
- A full board evicts the oldest Done card; removing a missing task is a no-op.
- The last column is held while a tab's agent is connecting.
Interaction
- Undo stack (10) of field-level reverts, bound to secondary-z on the board.
- A/D/P/R and Shift-F10 on the selected card; Esc cancels a drag first.
- "Filtered · Clear" chip; stale group filters clear; the sidebar count ignores
filters; arrows skip folded Done cards; zoom is restored after the board.
- Agent picker opens downward and scrolls; toasts are width-capped.
- Toggle Board off macOS is ctrl-shift-y (alt-0 took Meta-0 from readline).
CLI
- task done clears paused; relative --cwd is made absolute; --worktree needs
--cwd; task ls errors on a server without the board.
main landed the worktree lifecycle (#1009): a fresh base, .worktreeinclude,
.tty7/setup, recoverable removal and `tty7 worktree`. The board now rides it
rather than keeping its own:
- A task's worktree run is cut by worktree::create_for on top of create
(fresh base, retired names skipped, a slashed branch in a flattened
folder) and opened through the dialog's own start_worktree — setup, once
approved, then the agent — factored out so both open the same way.
- The agent's line is setup::agent_line; CLIAgent::prompt_args gains the
agents the board knew take a first message (Cursor, Qwen, Copilot,
OpenCode), and task::prompt_flag goes.
- Clean up removes through worktree::remove, which snapshots the checkout
and keeps an unmerged branch — so it no longer asks first, and its note
names any branch it kept.
- The CLI keeps both `tty7 worktree` and `tty7 task`.
A tab's auto group comes from probing its cwd for a repository. Any
failure of that probe - git failing to spawn, the macOS /usr/bin/git shim
dying while Xcode is mid-switch, a remote link dropping - came back as
"not a repository", overwrote the tab's remembered group, and was never
re-checked while the pane sat idle. Tabs in perfectly good repositories
dropped into Ungrouped and stayed there.
- Read root, home and branch in-process on this machine with
gix-discover instead of three git processes. Only the line counts
still come from `git diff --numstat`, so they keep matching the diff
views; a detached HEAD is still named by git for the same reason.
- Remote hosts keep asking their own git (a new control request would
force a dialect bump), but the probe now tells "not a repository"
(exit 128, or the directory is gone) apart from a failure.
- A failed probe leaves the cache as it was, so a tab keeps its
remembered group, and an unanswered cwd is retried every 10s.
* feat(worktree): setup script, .worktreeinclude, fresh base, recoverable removal
- Start new worktrees from the remote default branch, fetched first, with
--no-track; fall back to the current branch without a remote.
- Carry gitignored files listed in .worktreeinclude over from the main
checkout, copy-on-write (clonefile on macOS, copy_file_range elsewhere);
remote hosts copy through the Host trait under a size budget.
- Run .tty7/setup in the first pane before the agent, with TTY7_ROOT_PATH,
TTY7_WORKTREE_PATH, TTY7_WORKTREE_NAME and a per-worktree TTY7_PORT block.
The script only runs once its exact content is approved for the repo.
- The New Worktree dialog picks what the first pane starts (Shell or a
recent agent) and takes a task for agents that open on a first message.
- Removal snapshots the checkout, uncommitted work included, under
refs/tty7/trash/<name> first; the ref also retires the name. A branch
git refuses to delete is reported instead of silently kept.
- Hide .tty7/worktrees via info/exclude rather than a catch-all
.tty7/.gitignore, so .tty7/setup can be committed.
* feat(cli): tty7 worktree new/ls/rm
- worktree new: the GUI dialog's worktree from the command line — create,
carry .worktreeinclude, open a tab named after the branch, and type
.tty7/setup && <agent> [task] into it. Prints the path first.
- worktree ls: every checkout of the repo, tty7's marked, with the live
panes working in each.
- worktree rm: refuses while panes are inside unless --close-panes, and a
dirty checkout unless --force; reports the snapshot ref and a kept branch.
- Move shell_quote and the first-line builders into tty7-core so the GUI
and the CLI type the same line.
- Docs: CLI reference and the Worktrees page cover .worktreeinclude,
.tty7/setup, TTY7_PORT and recoverable removal.
* fix(worktree): run setup and the agent inside the worktree; Start is a dropdown
- The first line now opens with cd into the worktree: a shell's startup
files can move the pane, and setup then ran in (and wrote into) the main
checkout.
- The Start choice is a dropdown listing Shell and every agent this machine
offers, instead of a segmented switch capped at three.
Rewrites the New task sheet to the v3 comp.
- Header: New task in [folder · name · branch ▾] — one button opening a
searchable list of the sidebar's places with their branches; typing a
path offers it as a place of its own. A close button on the right.
- A six-line box for the words, as before.
- Footer: the agent as a button opening its list (1–9 pick while it is
open), a divider, a New worktree | In place segmented switch, and the
branch: editable for a worktree (the title's name shown until you type
one), the checked-out branch for in place. Add to queue, Start ⌘↵.
- Esc closes an open list first, then the sheet.
- core: Task::branch keeps a named branch; worktree::create_for keeps a
slashed branch (feat/eu) in a flattened folder (feat-eu).
⌘⌥B was three keys. ⌘I is two, one-handed, and bound to nothing else — ⌘E
was the first pick but Search Everywhere keeps it for its edit gesture.
Off macOS, Alt+0 sits in front of Alt+1…9, the tab chords there. The
sidebar's Board row gets a tooltip showing the live chord, and the View
menu lists Board.
- Claude's AskUserQuestion also goes through the permission dialog, and the
PermissionRequest that follows its PreToolUse turned the question into a
permission prompt: the card offered Allow on a multiple choice. The hook
now reads a question tool's permission request as a question, and the
state machine keeps a waiting question through one (for older hooks).
- The hook carries the question and its options (tool_input.questions) as
AgentAsk, and names a bare permission prompt after what it would run
('Bash: cargo test').
- A waiting question shows its text and numbered answers on the card and
in the panel, with Answer in terminal (the picker takes arrow keys, which
the board does not fake); a permission prompt keeps Allow. No reply box
while waiting: typed words answer neither.
- Output no longer puts a space between the characters of CJK text: the
spacer cell of a wide character is skipped.
Between Start and the agent showing up in its tab — the shell starting,
the command being typed — the run's tab has no agent in it, and a run with
no agent read as finished: the card jumped to Review and back. A run whose
tab is open and which started under two minutes ago now reads as starting
(task::STARTING, an agent yet to take its first turn), which is Running.
Past the grace, a run that never started is over after all. The same for
`tty7 task ls`.
Bumps gpui-component to e9dd0538:
- The find bar is one filled pill (search glyph, field, case, replace,
"3 of 6" count, up/down, close) with no border or rule, and it no
longer stacks its own padding on the editor's.
- The current match is amber, the other hits a neutral wash, so Enter
visibly moves between them in any theme.
- ⌘⌥F / ⌘R (Ctrl+H elsewhere) opens find with the replace row.
The breadcrumb row drops to 22px and sets the symbol in the code font.
The v2 rewrite dropped it. A card's menu now offers what its column can do
— open terminal, start, reply, pause, allow, request changes, mark done,
reopen / start again, clean up, resume — then Edit… and Remove for a task,
or Keep as task for an agent started by hand (with Undo).
- Clean up (a Done card's panel, or Clean up all on the Done column) closes
the tabs a task's runs opened in worktrees, deletes those worktrees and
their branches, and takes the cards off the board. When that would lose
uncommitted changes or commits not merged into the main checkout's
branch, it lists them and asks first; otherwise it just does it. No undo
— a deleted worktree cannot be brought back, which is why it asks.
- A card whose last run's worktree no longer exists says so, and its panel
offers Start again (a fresh run) instead of Reopen or Resume.
- Done shows the last seven days; older cards fold into one row.
- core: worktree::discard_check / discard.
- New task's footer is now a two-sided switch, New worktree | In place,
followed by what the choice comes to: the branch name, or the folder.
- Output (card line and peek) reads the screen above an agent TUI's input
box — cut at the rule pair near the bottom — so it shows what the agent
said instead of its status bar, and skips the spinner's summary line.
The peek shows twelve lines of it.
Rewrites the board to the v2 interaction comp (src/ui/board/).
- Click a card for a peek panel beside the columns (agent, repo, branch,
changes, the prompt, the agent's latest screen lines, what it waits on,
files changed from `git diff --numstat HEAD`) with a reply line and the
column's actions. Double-click / Enter opens its terminal; a queued task
opens for editing.
- Drag a card only where its agent can go: start, pause (ESC + a `paused`
mark that holds until the agent works again), allow & resume, request
changes (focuses the reply), mark done. Targets say the verb; the rest
fade.
- Waiting cards: Allow for a permission prompt, Reply for a question —
`AgentSessionState::question` now tells the two apart.
- A toast says what happened, with Undo for what the board itself changed.
- ← → ↑ ↓ move between cards, Esc peels back reply → panel → selection →
board, C (or N) opens New task.
- New task: "in" place chips from the sidebar, one text box (first line is
the title), agent pills, and a footer showing the branch the run gets —
click it to run in place instead.
- Agent filter is a multi-select with counts; empty columns say so.
- The New task card's Group picker becomes Where: the sidebar's groups, in
its order, each with the folder its tabs work in (a pinned group's own
folder or first tab's, an automatic group's repository), then past a
divider the folders of tabs in no group. Picking a pinned group also files
the task under it. Defaults to the place the active tab is in.
- While the board is showing, no tab row is drawn as the current one.
- The New task card is drawn at window level with a scrim over everything,
like the other sheets, instead of inside the terminal area.
The New task card gains a Group picker (by repository, or any pinned
sidebar group — a folder group also sets where the task runs) and a "Run in
a new git worktree" switch, remembered for the next task.
- `Task::group` / `Task::worktree`, `Run::worktree` (where the run's work
is, for cleanup later).
- Start with a worktree cuts one off the thread with `worktree::create_for`
— named after the title (`branch_slug`), numbered when taken, a generated
name for a title with no ASCII words — and opens the run's tab in it.
- A run's tab is filed under the task's pinned group.
- Cards show their pinned group; the board header filters by group.
- `tty7 task add --worktree --group NAME`.
gpui paints a prompt as a root of its own, beside the window's Root, so it
inherits nothing Root sets: the card fell back to gpui's .SystemUIFont
instead of the Interface font the rest of the chrome uses. Also add a test
that the quit-and-stop question never falls through to the platform dialog
(gpui's unthemed single-line fallback on Linux, #920).
OpenCode 2.x only loads a default export shaped { id, setup | effect } and
rejects the file otherwise ("Plugin must export a default definition with
an id and an effect or setup function"). The generated tty7.js only had a
named export, so every 2.x user got a load error.
- Export default { id, server, setup }: 1.x (>= 1.3.4) reads `server`,
2.x reads `setup`; the named Tty7Presence export stays for older 1.x.
- 2.x: subscribe via ctx.event.subscribe(), read event.data, map
permission.asked, and treat session.created with a parentID as a child
session. Stay inert inside the shared --service process, whose sessions
belong to no single pane.
- Spawn the emitter directly with node:child_process instead of
`sh -c`, which does not exist on Windows.
A host with `Compression yes` (every one imported from an ssh config that
sets it) negotiated zlib@openssh.com, and the pinned ayamir/russh rev cut
every packet that inflated past 2x its compressed size. The zlib stream
desynced right after auth: the session showed as connected and never
printed a byte.
- Move the [patch.crates-io] pin to l0ng-ai/russh (branch tty7): ayamir's
gssapi-with-mic commit plus Eugeny/russh 58886f4d and 24e2c374.
- Add an end-to-end test that runs a zlib session against an in-process
russh server and checks every byte of a compressible + incompressible
payload arrives (0 of 270336 bytes on the old pin).
- Re-importing an ssh config now updates `algorithms` on hosts that already
exist, so dropping `Compression yes` and re-importing takes effect.
A Board row under the sidebar search (with a count of agents waiting on
you) swaps the terminal area for five columns of cards: this workspace's
tasks, plus every tab running an agent no task claims. Columns come from
`task::column` / `task::live_column` on every frame.
- New task (N): title, prompt, agent; Add to queue or Start. Start opens a
tab named for the task and launches the agent with the prompt as its
first message, staying on the board.
- Cards: agent avatar, title, repo · branch, what a running agent is doing,
the question a waiting one asks with an Open button, diff counts, age.
Click opens the tab; right-click has start/resume/done/reopen/edit/delete,
and "keep as task" for an agent started by hand.
- Runs record their agent's session id, so a closed run can be resumed.
- Toggle Board: secondary-alt-b, and in the command palette.
A workspace now keeps a board: `Workspace::tasks`, each a title, a prompt,
where to run it, which agent, and the runs started for it. Tasks ride the
machine tree like the sidebar groups do — persisted with it, moved as
`TaskPut` / `TaskRemoved` layout deltas, gone with the workspace.
A task stores no column. `task::column` reads it off the agents in its runs'
tabs (Queued, Running, Needs input, Review, Done); the only verdict kept is
the user's "done", and it yields when an agent takes another turn.
Compatibility: a client now names what it can decode in
`ControlHello::features`, and a server holds the board's deltas back from a
client that did not say `tasks` — an event an older GUI cannot decode would
end its link. The server advertises `tasks` so a newer client never sends
`TaskPut` to an older server.
`tty7 task ls|add|done|reopen|rm` works the board from the CLI; the bundled
skill documents it.
The hosted Mintlify build fails to parse any page with a JS comment (line
or block) inside an export body and serves a parse-error placeholder
instead; mint dev and mint validate accept the same page. Confirmed with
diagnostic pages: the prefix with the sidebar's // comment fails, the
same prefix without it renders, and turning it into /* */ still fails.
Move both comments to top-level MDX comments, note the rule in the file,
undo the earlier % escaping (that guess was wrong), and remove the
diagnostic pages.
The % fix did not bring the hosted landing page back. The first // line
comment in the file sits in the range that breaks, so turn the two into
block comments, and add temporary unlinked pages that isolate the
remaining suspects. They are removed once the cause is confirmed.
The header keeps only the most recently fronted files (3 docked, 7 filled,
fewer with side panels open) in their strip order; the rest sit behind a +N
button that lists every open file with a filter, keyboard navigation and
Close saved / Close others. A two-cell Dock/Fill switch replaces the header's
right-click menu, and a filled editor leads with a pill naming the terminal
it covers that docks it back.
Breadcrumbs lose their rule and use chevrons, with only the file name in body
ink. The status bar is 28px, leads with a missing language server, and reads
cursor, indent, encoding, line ending, language; the actionable readouts
answer hover and the cursor opens Go to Line.
The hosted Mintlify build percent-decodes page content before parsing
it, so the pane id "%22" in the demo became a bare quote and the whole
page fell back to the parse-error placeholder. Local mint dev/validate
do not decode, so they never saw it. Spell the pane ids' % as \u0025.
Also drop the temporary diagnostic pages used to bisect this.
The header keeps only the most recently fronted files (3 docked, 7 filled,
fewer with side panels open) in their strip order; the rest sit behind a +N
button that lists every open file with a filter, keyboard navigation and
Close saved / Close others. A two-cell Dock/Fill switch replaces the header's
right-click menu, and a filled editor leads with a pill naming the terminal
it covers that docks it back.
Breadcrumbs lose their rule and use chevrons, with only the file name in body
ink. The status bar is 28px, leads with a missing language server, and reads
cursor, indent, encoding, line ending, language; the actionable readouts
answer hover and the cursor opens Go to Line.
The alert card is a fixed 360px and its buttons never shrink, so the update
prompt's three answers (Update and relaunch / Install on Next Launch / Later)
ran past the edge and were clipped. Prompts with three or more answers now
use a 460px card, and the answer row wraps (still flush right) as a fallback
for locales with longer labels.
#1004 stats the source of a paste or drop upload to decide whether to
upload recursively. That path comes from this machine's clipboard or
desktop, so it is a local read by construction.
Copying a file in Finder and pasting it into an SSH pane, or dropping one
onto it, used to paste this machine's path — which the remote program
cannot open. Only clipboard images were uploaded first.
Every local path a pane is handed now goes through one route: uploaded
into its own directory under ~/.cache/tty7/clipboard on an SSH host (so it
keeps its real name), rewritten for WSL, and pasted as-is locally. Folders
upload recursively, a transfer is only abandoned once it stops moving, and
staged pastes older than a week are pruned.
Rows of a remote Files tree now drag as their own type instead of
ExternalPaths, so no drop target mistakes a far-side path for a local file.
* fix(keymap): let the code editor's multi-cursor chords beat the pane keys
gpui-component now binds secondary-d, secondary-shift-l and
secondary-alt-up/down in the Input context for multiple cursors. A
context-free binding ranks as deep as the focused context and ties go to
the one added last, so tty7's SplitRight and FocusPaneUp/Down took those
keys inside the editor. Re-add the editor bindings after tty7's table; other
text fields have no handler for them and fall through to the pane keys.
* feat(editor): show the selection count in the status bar
With several cursors the Ln/Col readout (the primary caret's) is followed
by "(N selections)".
* feat(editor): git change markers in the gutter
Diff each buffer against its file's index version (what VS Code's quick
diff and the SCM panel's Changes compare with) and hand the hunks to the
editor as gutter markers: added, modified, and a wedge where lines were
deleted. The base is read with `git show :./name` through the buffer's own
host, so remote workspaces work too; SFTP buffers and untracked files get
no markers. It is re-read when the repository's SCM epoch moves, on save
and when the path changes; the diff itself is a line-level Myers diff run
off the UI thread shortly after each edit.
Next/previous change and Revert Change (one undo step, also in the
right-click menu) are commands; clicking a marker opens a peek of the
staged lines with a Revert button. The editor watch now also follows the
repository the gutter found, so a stage or checkout refreshes the markers.
The `editor_git_gutter` config (default on) is flipped by the
ToggleEditorGitGutter command.
* feat(editor): go to symbol, breadcrumbs, and back/forward navigation
Go to Symbol (Cmd-Shift-O in the editor) lists the file's outline on a new
Symbols tab of Search Everywhere: indented by nesting while browsing, ranked
flat with the containing symbols as a subtitle while searching. Arrowing
through the rows previews each symbol; Escape puts the caret and the scroll
back, Return keeps it.
The outline comes from the tree the highlighter already parsed, with a small
query per language (Rust, Go, Python, JavaScript, TypeScript/TSX, C, C++,
Java, Markdown, Ruby, shell). Tty7App::editor_set_document_symbols lets a
language server's documentSymbol answer replace it per buffer.
A breadcrumb row over the text shows the file's path from its project root
and the symbols around the caret; the symbols open Go to Symbol.
Back and forward (Ctrl-- / Ctrl-Shift-- on macOS, Alt-Left/Right elsewhere)
walk a per-tab history. Jumps are noticed by sampling the caret whenever the
editor draws: a change of file, or a move of ten lines or more without an
edit, records where the caret was. Quick open, go to line, file links and
anything that goes through open_file_in_editor_at are therefore captured
without hooks of their own; a place in a closed file reopens it.
* feat(editor): bind next/previous change to Alt+F5 in the code editor
Bind EditorNextChange / EditorPrevChange to alt-f5 / shift-alt-f5 in the
Input context only, after tty7's own table, so a terminal never loses the
function key. Mark the hunks stale right after a revert, before the
input's Change event lands, and cover the whole loop (markers, stepping,
revert as one undo) with a window test.
* feat(editor): line commands in the editor's right-click menu
Toggle Comment, Move Line Up/Down, Duplicate Line, Delete Line and Go to
Matching Bracket, dispatched to gpui-component's new editing actions so
each row shows its chord. Strings in en, zh and ja.
* feat(editor): language servers for the code editor
A new ui::lsp module runs language servers for local files the editor
opens: rust-analyzer, typescript-language-server, pyright (or pylsp),
gopls and clangd, from a registry table. Each server is keyed by
(server, project root), found from markers such as a Cargo workspace,
package.json, go.work/go.mod or pyproject.toml, and shared by every buffer
under that root. A server missing from PATH (which tty7 already fills from
the login shell) means no LSP for that language and a one-line hint in the
status bar.
The JSON-RPC client frames Content-Length messages over the server's stdio
on dedicated threads, holds everything back until initialize is answered,
cancels requests nobody waits for any more, and answers the server's own
requests (configuration, capability registration, applyEdit). Documents
use full-text sync, debounced, and flushed before every request. A server
whose last file closed shuts down after a grace period, every server exits
with the app, and one that crashes is restarted a few times before it is
left down.
Features: diagnostics as underlines with hover messages and an error and
warning count in the status bar; completion (snippets flattened to plain
text); hover; go to definition by secondary-click or F12, across files
through open_file_in_editor_at; code actions on the editor's own menu
(cmd-.), resolved and executed as the server needs; Format Document
(shift-alt-f); and Rename Symbol (F2) in the editor's bar, applied to open
buffers and to files on disk. The key bindings sit in the Input context so
F2 and F12 stay with terminal programs.
Positions are converted at the boundary: servers count UTF-16 units,
gpui-component counts chars, and the rope counts bytes.
The new editor_lsp setting (default on) turns it all off.
* fix(editor): clear the change markers when the file loses its base
A file that becomes untracked or leaves its repository kept the markers
of its last diff; clear them when the base goes away. Guard the base read
against a panic, which would otherwise leave the fetch flagged forever,
and test the read against a real repository: the base is the staged
version, and untracked files have none.
* test(keymap): the editor's navigation chords win inside the editor, not in a terminal
* fix(keymap): let the code editor's line commands beat the app's chords
The editor binds toggle comment, move/copy/delete line, insert line, select
line and go-to-bracket on its CodeEditor key context. A context-free app
binding ranks as deep as the focused context and wins the tie by being
added later, so ⌘/ (shortcut sheet), ⌘↵ (fullscreen), ⌘⇧↵ (maximize) and,
off macOS, ⌥↑/⌥↓ (pane focus) took those keys inside the editor. Re-add
them in fixed_bindings on CodeEditor, which only a multi-line code editor
declares, so plain text fields and the terminal keep the app's keys.
* fix(keymap): route cmd-K cmd-D to the code editor's skip-occurrence
The chord starts with ClearScrollback's key on macOS, and gpui drops a
pending chord that ranks below a complete match, so the fork's binding
never got its second key. Re-add it after tty7's table, in the CodeEditor
context only, so other text fields don't wait on cmd-K.
* feat(editor): history follows edits, and paging is not a jump
Places in the back/forward history now move with lines inserted or deleted
above them, read from the editor's line-edit log on every change. The caret
move a Page Up/Down, paste, undo or redo makes is heard through the
keystroke that caused it and is not recorded as a jump.
* feat(editor): Problems list, keyboard change peek, Editor settings
- Problems: every error, warning and note the language servers published
for the open files, grouped by file, at the foot of the code panel.
The status bar's counts and ToggleEditorProblems (Cmd/Ctrl+Shift+M)
open it; a row opens its file at the line and column. Read through a
new LspStore::diagnostics_snapshot, mapped to editor columns.
- EditorPeekChange (Alt+F3 in the editor) peeks the change under the
caret, or goes to the next one. The peek now takes the keyboard from
a click too: Enter reverts, Escape closes and hands focus back.
- Settings > General gains an Editor group: git change markers,
language servers, soft wrap and rendered Markdown, searchable and
resettable like every other row.
* feat(lsp): outline, references, workspace symbols, signature help
- documentSymbol feeds the editor's outline (breadcrumbs, Go to Symbol)
through editor_set_document_symbols, refreshed 500 ms after typing
pauses. Flat answers are nested by range; an empty answer from a server
still indexing leaves the tree's outline in place.
- Find All References (shift-F12) and a definition with several answers
open a Locations tab in the search. Arrowing through it previews a place
in the file in front, and Return goes there, into any file.
- Go to Symbol in Workspace (secondary-T inside the editor) asks the
server's workspace/symbol as the query is typed, into the same list.
- Completion items are resolved for their documentation and auto-import
edits, which are applied on accept (with the gpui-component fork).
- Signature help opens on the server's trigger characters (or on '(' and
','), stays current while typing in the call, and closes when the server
says the cursor has left it or on Escape.
- Diagnostics are replaced wholesale on publish; between publishes the
fork now carries them through edits instead of dropping them.
- workspace/configuration answers from per-server settings, with an empty
object for a section tty7 sets nothing for. rust-analyzer gets
checkOnSave with cargo check, also as initializationOptions, and every
server gets didChangeConfiguration after initialized.
* feat(editor): text commands in the palette and keymap
Transform to Upper/Lower/Title Case, Trim Trailing Whitespace, Join Lines
and Remove Surrounding Brackets, as tty7 actions (bindable on the
Keybindings page, unbound by default) and as palette rows offered while a
buffer is open. Both run gpui-component's editing action on the active
buffer. Join Lines gets VS Code's ctrl-j as a fixed CodeEditor binding on
macOS, where the terminal keeps it as a line feed. Strings in en, zh, ja.
* feat(editor): split the editor into two groups
Cmd-\ (Ctrl-\ off macOS, bound only inside the editor so the terminal keeps
SIGQUIT) opens the file in front in a second group on the right. Each group
has its own file in front and, for different files, its own caret and
scroll; Cmd-Alt-Left/Right (Ctrl-Alt off macOS) or a click moves the focus
between them, and a group whose last file closes goes away. The split is
saved with the tab's other editor state.
The focused group is always TabCode's own files/active and the other waits
beside it, so everything that acts on the file in front - saving, go to
line, language servers, change markers, multiple cursors, history - follows
the focus unchanged. A file shown in both groups is drawn once, in the
focused one; the other shows a placeholder that brings the focus over. A
second InputState kept in sync would have needed every hook attached twice.
Also: palette rows and View menu items for Go to Symbol, Back, Forward and
Split; Cmd-Shift-O closes Go to Symbol when it is open; the status bar no
longer repeats the path the breadcrumbs show (a rendered Markdown file keeps
its breadcrumb path); change markers are kept current in both groups.
* test(keymap): the editor group chords win inside the editor
* fix(lsp): close a window's documents when the window closes
Documents were only closed by sync_window, which runs when a window's
buffer set changes. Closing a window never ran it, so no didClose was
sent, the idle shutdown never started, and a language server lived on
until quit (forever, with the app retired to the tray).
* fix(editor): restore a split whose left group had no recorded files
The recorder writes files: [] with a split when the left group held only
untitled or remote buffers, but restore returned early on an empty left
list and dropped the right group too.
* fix(editor): forget a swept orphan buffer's navigation state
The orphan sweep dropped clean buffers without calling forget_buffer, so
each one's outline cache (a full copy of its text), LSP symbols and
edit-log cursor stayed in EditorNav for the life of the window.
* fix(lsp): owner-only sync, stale-edit checks, request timeouts, re-enable
- Only the buffer that owns a document may use its server. The same file
open in another window used to send its own text as didChange on F12,
rename, references or signature help, swapping the document under the
owner. LspStore::context now takes the requester and refuses a
non-owner quietly, before anything is sent.
- apply_workspace_edit checks every open buffer an edit touches against
a baseline: the texts when a rename was asked for or the code-action
menu was filled, or the text the server last heard for its own
workspace/applyEdit (which then answers applied: false). A buffer typed
in, opened or closed since means nothing is applied.
- A request made after the server's output closed fails at once instead
of waiting forever. Requests time out after 10 s (initialize after 60 s,
shutdown after 2 s) and cancel themselves on the server.
- Turning editor_lsp back on asks every window for its open files again,
which starts their servers. Windows register how to be asked; closed
ones are forgotten.
* test(nav): spell out LineEdit's new at_line_start field
gpui-component's LineEdit now records an insertion at column 0, which
moves the whole line down. The literal edits in this test are mid-line.
* fix(editor): a restore merges into the tab, and commands follow the group focus
Session restore used to assign the recorded groups over whatever the tab
held when its files finished loading, so a file opened or a split made in
the meantime was lost. TabCode::restore_groups keeps a split made meanwhile
as it is, and otherwise lays out the recorded groups and puts the files
opened meanwhile back into the focused group, the last of them in front. A
restore the reader has moved on from no longer takes the keyboard, and never
hides a panel they opened.
The group focus only followed the keyboard when the editor drew. Keys are
safe - gpui draws a window whose focus moved before dispatching the next
key - but a command from the menu bar or a context menu is dispatched
without a draw, and acted on the group that had the focus before. A
capture-phase listener for every editor command on the editor's element now
settles the group first, wherever the command's handler sits.
* fix(editor): leave cmd-T to New Tab; offer workspace symbols from the palette
Inside the code editor cmd-T was rebound to Go to Symbol in Workspace,
which made tty7's most-used chord mean two things depending on focus.
It is New Tab everywhere again. Workspace symbols stay reachable as an
Editor palette row and as a rebindable, unbound action.
* build: pin gpui-component to the fork's editor work (0e7541fb)
* fix(search): let the editor's pickers stand alone in Search Everywhere
Go to Symbol, a language server's places and Go to Symbol in Workspace
opened on hidden tabs, so the window-wide scope row (All, Terminals,
Sessions, Hosts, Commands) sat over them with nothing selected, and Tab
swapped the list for the terminals. They now show a heading in place of
the row (References / Definitions / Symbols / Workspace Symbols, with a
count), Tab stays put, and the footer drops the scope hint.
* fix(search): Go to File stands alone like the editor's pickers
Go to File (cmd-O) is reached only by its chord, yet it sat under the
scope row with nothing lit and offered Tab to leave for the terminals.
Every tab outside the row now stands alone the same way: its name in
place of the row, Tab stays put, no scope hint in the footer.
* feat(search): give the editor its own scope row — Files, Symbols, Workspace Symbols
Go to File, Go to Symbol and Go to Symbol in Workspace were three
separate pickers, each on its own chord. They now share a second scope
row, the editor's, next to the window's: cmd-O and cmd-shift-O open on
it and Tab walks it. Only tabs that can answer show: Symbols needs a
file in front, Workspace Symbols a language server that searches the
project. A row of one shows as a heading. Each tab is opened the way its
chord opens it, so it arrives set up; references and definitions still
stand alone.
* feat(search): fold Workspace Symbols into Symbols
Symbols and Workspace Symbols answered the same question at two scopes.
Symbols now does both: with nothing typed it is the file's outline; once
a query is typed, the front file's language server is asked across the
project and its answers are listed after the file's own, each under a
heading when both have rows (the front file's own hits are dropped from
the project's). The separate tab, action and palette row are gone.
* fix(search): call the language server's project results Project, not Workspace
LSP's workspace/symbol searches the server's project root, which has
nothing to do with a tty7 workspace (a group of tabs). The Symbols tab's
second section said Workspace, reading as if it searched those. It says
Project now, and the tty7-facing names follow (project_symbols,
set_project_symbols, lsp_project_symbol_query); only code that speaks
the protocol keeps its word.
* ci(host-boundary): allow the language servers' local reads
ui::lsp only ever holds local buffers (OpenFile::local refuses any other
host) and runs its servers on this machine, so the files it reads to
measure a column, apply a rename to disk or find a project root are on
this disk. Each call is allowlisted with that reason.
* test(editor): spell test paths so they hold on Windows
The language-server tests used /p/... paths, which are not absolute on
Windows and so have no file:// URI; they now build platform paths
(lsp::test_path) or spell the URI out. The gutter and split tests
canonicalized their temp dirs to get past macOS's /private symlink,
which on Windows yields the \\?\ form no editor path is ever in; they
share a helper that canonicalizes everywhere but Windows.
* test(editor): resolve temp dirs the way the editor does
On the Windows runner the temp dir is an 8.3 short name (RUNNER~1),
which the editor's load expands through Host::canonicalize. The split
tests now resolve their fixtures through that same call instead of
guessing per platform.
- Interrupts: an Esc / Ctrl+C (legacy, kitty and modifyOtherKeys forms)
on a pane whose agent is mid-turn arms a 1s settle; if no hook event
arrives, the turn is assumed over and goes Done. Claude's Stop skips
user interrupts, so panes used to stay on working until the next prompt.
- Stale turns: a daemon sweep moves a turn that has been Working with no
hook event for 30 minutes to Idle.
- Both set `inferred` on the session; the next real event clears it, and
a tool finishing after a guess puts the turn back on Working. Inferred
states raise no finish notification and no unread badge.
- Claude and Codex now hook PermissionRequest, and PreToolUse for their
ask-the-user tools (AskUserQuestion / request_user_input), so Waiting
shows the moment the prompt opens. Codex also gains PostToolUse, so it
leaves Waiting once the approved tool has run.
- The "finished" desktop notification waits 1.5s and is dropped if the
next turn starts first (queued message, Stop hook sending it back).
Markdown tables (Claude Code's among them) wrap a long cell by hand: each
row is a hard newline framed by box-drawing borders, with the next cell's
text in between. Hovering or clicking a URL wrapped that way only ever got
the fragment on one row, so the link opened truncated.
Link lookup now reads a table cell the way it already reads a wrapped row,
just inside the cell's own columns: a row carries on into the next when its
text reaches the right border and the next row's starts at the left one,
with link characters on both sides and the borders lined up. Only `│┃║`
count as borders; a bare `|` is too often a pipe. Cells that fit on one row
and double-click selection are unchanged.
The hover underline is now a run per row instead of one start..end span, so
a stitched link underlines just its cell rather than the borders and
neighbouring cells between its rows.
The PR detail now leads with what it is usually opened to find out:
- Checks: check runs and commit statuses on the head commit, failures
first, with durations and links to their logs. A section with more
than five folds the passed and skipped ones into one row.
- Reviews: one row per reviewer (approved, changes requested,
commented, requested), folding the way GitHub's sidebar reads them.
- A merge-state line under the branches ("Waiting on 1 check",
"1 check failing", "Merge conflicts", "Ready to merge", ...).
Checks and reviews that cannot be read are left out instead of failing
the whole detail. While a check is running, just the checks are re-read
every 20 seconds (signed in only); once every verdict is in, the detail
is read again for the new merge state.
The list pins the pull request of the pane's branch under the repo row,
looked up through the branch's upstream so a fork's branch is found
under the fork's owner.
Long sections fold: comments past four keep the first and the latest
two, long descriptions and comments are clamped behind "Show full text",
and reviewers and changed files show a few with a "show all" row.
The + menu lists up to three agents that have actually been run, beside
Local and SSH. Other Agents… opens Search Everywhere already filtered to
agent. New Agent Tab still starts the one used last.
Refs #955
Co-authored-by: stevelliu <stevelliu@tencent.com>
The docs root becomes a custom-mode landing page modelled on the Claude
Design "Terminal Redesign v5" window. The hero is an HTML/CSS rebuild of
that window that autoplays five chapters taken from the promo storyboard:
agent status and notifications, one agent driving another through the
tty7 CLI, the editor prompt, Search Everywhere, and sessions outliving
the window. It follows the docs light/dark theme and pauses off screen.
Agent avatars use the app's own marks and brand colours (CLIAgent::
accent_rgb / icon_path), and status dots use AgentStatus::dot_rgb.
The previous introduction moves to /introduction, and the navbar logo
now links to the landing page instead of GitHub. All landing-page CSS
is scoped under .t7h / .t7w, since Mintlify loads it on every page.
The rule between kept and derived groups sat in the list as a child of
its own, between two GROUP_GAPs, so kept groups stood more than twice as
far from the rest as groups stand from each other. It now takes up the
one gap instead of adding another.
The kept-group mark is a drawn pin rather than a diamond glyph, on the
header and on the pin button an auto header shows on hover.
Right-clicking the empty sidebar under the tabs did nothing. The room
below the last row now opens New Tab and New Group.
* fix(deps): gpui-component keeps highlight boundaries on char boundaries
Typing Chinese through the IME in the code editor could panic the app:
after a sync parse ran past its 2ms budget, the stale injection layers
put a style boundary inside the committed glyph and the text system split
the line mid-character. Debug builds miss the budget often enough to hit
it; the fork now snaps every style range to the current text.
* feat(ui): bring the modal cards onto the v5 design
- Confirmations take v5's alert shape: title and detail as one
paragraph, answers beneath, no header row or footer rule, 360px wide
and set lower, at eye height.
- Dialog buttons take the field's 7px corner and 14px padding; a
secondary answer rests on the well's faint fill instead of bare text.
- The scrim dims rather than blacks out: 45% dark, 14% light.
- The New Workspace form joins the other cards: 12px corner, borderless
wells for its fields, an esc cap and the shared 40px footer.
* feat(editor): draw the editor's right-click menus like the rest of the window
The text's menu was gpui-component's native OS menu: another font and
material, no shortcuts, and Go to Definition / Show Code Actions that no
language server ever enables. It is now a PopupMenu with Attach to Agent
(the selected lines ride along as #L3-9), Undo/Redo, the clipboard,
Find, Go to Line, and the file's own items: Open in Browser for web
files or Open with Default App, Reveal, Copy Path, Copy Relative Path.
The file tabs get a menu too: Close, Close Others, Close to the Right,
and the same file items. Closing several asks once about unsaved edits.
* chore(deps): gpui-component moves the caret on right-click under a host menu
* feat(agents): add Qoder CN CLI integration
* fix(agents): spell Qoder CN's config override QODERCN_CONFIG_DIR
The China build of Qoder resolves its configuration through QODERCN_CONFIG_DIR.
The first pass invented QODER_CN_CONFIG_DIR instead, so an install that set the
real one was treated as unrelocated: hooks went to ~/.qoder-cn and history was
scanned from a directory the CLI never writes to. The test that should have
caught it set the same invented name, so it only proved the name agreed with
itself.
Picks up the rest of the review as well — detect the `qoder-cn` dispatcher
beside the other two binaries, call it the mainland-China build rather than a
different vendor, and drop the QODER_CN_HOOK_EVENTS alias for the table it only
pointed at. The serialized enums keep their variants appended; only the
independent ALL arrays moved QoderCLICn next to QoderCLI.
* fix(path): read the interactive shell's PATH, not just the login shell's
The GUI starts with launchd's bare PATH and refills it by running the login
shell. A login shell reads .zprofile/.bash_profile and never .zshrc/.bashrc,
so every directory exported there was invisible to the app: agent quick
launch found only what /opt/homebrew/bin and /usr/local/bin happened to hold,
and an agent_launch override could not bring a missing program back, since
the override's program is looked up on the same PATH.
Probe with -i as well (fish unchanged: it reads its config in every mode) and
take the last non-empty line, so an rc that prints a greeting above the
echo $PATH cannot be mistaken for the value.
* fix(path): bound the interactive PATH probe and bracket its output
Running .zshrc/.bashrc on the startup path needs guards the login-only
probe could do without:
- Read the PATH between markers instead of the last line, so an exit
hook that prints after it cannot be taken for the PATH.
- Return as soon as the closing marker arrives rather than at EOF: an rc
that backgrounds a daemon hands it the pipe, which then never closes.
- Give up after 5s and kill the shell, so a slow or stuck rc delays
startup instead of preventing it.
- Probe after forwarding an open path to a running window, which has no
use for the PATH.
* docs(changelog): describe the bounded PATH probe
---------
Co-authored-by: stevelliu <stevelliu@tencent.com>
Co-authored-by: l0ng-ai <24760907+l0ng-ai@users.noreply.github.com>
l0ng-ai
dependabot[bot]
LiuSirandstevelliu
ARNO