- crates/vcs log.rs: Repo::log (topological, all refs, paging, literal
message/author filters, a path's history with --follow), show_commit
(message and files against the first parent, renames) and show_at
(a file at any commit); parsers property-tested.
- Engine git.log, git.showCommit, git.showAt in cmd/git_log.rs through
the step-1 hook.
- Log tab in the bottom panel: graph lanes carried across pages, ref
badges, filters, lazy paging, keyboard; commit details whose files open
a read-only diff at that commit in M4.3's viewer.
- vcs.showLog and vcs.showHistory (menu, tree context menu, active
editor tab), no default shortcuts.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Repo::run, check_name and SMALL_CAP become pub(crate); cmd/git.rs gains
Op::Custom, start_with and a pub(super) rel_path, so a new module adds an
Op::Custom through start_with instead of editing git.rs or repo.rs.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- lutra_proc::spawn_suspended: CREATE_SUSPENDED, join the kill-on-close
job, resume via a Tool Help thread snapshot. Opt-in for long-lived
children (Phpactor); git, php -l and the probe keep spawn because the
snapshot costs ~60 ms per start.
- lutra_proc::adopt + Guard (Windows): the terminal's ConPTY shell joins a
job, so processes it started end with the tab or with Lutra.
- lsp.completion cancels the previous pending completion on the same
server ($/cancelRequest); the cancelled command resolves empty.
- Syntax proptests compare leaf kinds, outline and folding instead of the
S-expression (tree-sitter-php 0.25.1 keeps a union_type wrapper after
an undo); Malte's seed added.
- docs/development.md: data dirs, target dir inside the repo, parallel
builds, deleting ui/node_modules.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- vcs: checking out a remote-tracking branch reads remote.<name>.fetch;
without a matching refspec it creates the local branch with --no-track
instead of leaving a dirty tree after git fails to set up tracking.
- vcs + engine: git.lastMessage returns HEAD's full message (null before
the first commit); the Changes window prefills Amend with it.
- ui: stores/vcsStatus.ts is the only git.status caller; the Changes
window, tree/tab colours and the branch item read its snapshot, so a
gitChanged costs one status query. RepoSummary carries upstream,
ahead and behind.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
On Windows the webview renders itself into a PNG through WebView2
CapturePreview (scheduled on the main thread via with_webview, 10 s
timeout, PNG signature and 64 MiB cap checked). macOS and Linux keep the
xcap screen-region capture as a documented fallback, now without focusing.
app.focus is the only control method that changes focus. A --control
instance opens its window without taking the foreground. An ignored live
test samples the foreground window while the app starts and takes five
screenshots and fails if Lutra ever owns it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The status bar shows the current branch (short hash when detached). Its
popup lists local, then remote branches with a filter and New branch;
checkout runs flushDirty first and toasts git's refusal. Commands
vcs.branches, vcs.newBranch and vcs.checkout.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
vcs.showDiff {path?, staged?} (Mod+Alt+Shift+D) opens a "Diff: <name>"
tab in the editor area: @codemirror/merge (MIT, loaded lazily, 27 kB /
9.7 kB gzip), with the index (or HEAD for the staged view) read-only on
the left, line breaks normalised to LF, and the working copy on the right,
editable through its normal engine buffer. vcs.nextChange (Alt+Shift+])
and vcs.previousChange (Alt+Shift+[) move between chunks. Binary, too
large, failed and deleted files show a notice. Entry points: the Changes
window, a new project tree context menu (Open, Show Diff; right click or
Shift+F10) and the palette/menu. Colours come from the --lt-vcs-* tokens.
21 Vitest tests; parity docs updated (Git 6% -> 8%, est.).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Depth headline inputs updated for H3 (Inspections 5%) and H4 (Settings 8%):
570/101, still ~5.6%.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- git.lineChanges {id} -> {ranges: [{kind, startLine, endLine}], version}:
the buffer against its index blob, line diff with similar (Myers +
Replace, no Compact) off the lock, CRLF-safe; index texts cached per
path and dropped on gitChanged (State::emit -> git_lines::observe)
- editor gutter markers for added, modified and deleted lines, queried
150 ms after edits, on show and on gitChanged, mapped through edits
- vcsStatus store (git.status on projectOpened and gitChanged, no
polling) colouring file names in the project tree and editor tabs with
the --lt-vcs-* tokens; contrast also checked on the active tab
- tests: unit and property tests, real-repo engine tests, Vitest
- docs: architecture, parity, gaps, roadmap, ui-parity, ROADMAP
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Session tick: 1 ms while Phpactor reports work-done progress and in a
session's first 120 s, otherwise 25 ms as before. Fast intervals use
thread::sleep, because recv_timeout wakes at most ~64/s on Windows.
First useful completion on 2,000 classes: 71.6 s -> 20.7-26.9 s.
- $/progress -> lspProgress {active, title?, message?, percentage?},
progress in lsp.status, a status-bar item (LspProgressItem).
- window/showMessage -> notification.lsp.message (repeats within 30 s and
the known Windows lint-provider complaint only logged); showMessage,
logMessage and stderr in a 1,000-line log, new command lsp.log.
- Lutra's own php -l on Windows (lsp/php_lint.rs): on open and save, one
worker thread, lutra_proc::spawn, stdin, 10 s timeout, output caps;
merged into diagnosticsChanged with source "php -l".
- editor.completion.delayMs stays 0 (measured: 100 ms only delays the
list; Phpactor marks every list incomplete).
- Fake server: scripted notifications after initialized.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
vcs.commit moves from Mod+K (the public default keymap's Commit) to
Mod+Alt+Shift+M, and vcs.openChanges from Mod+Alt+G (CodeMirror's go to
line in basicSetup, which the global listener would swallow) to
Mod+Alt+Shift+G. Both were checked against the public Windows and macOS
default keymap pages, Lutra's registered shortcuts and CodeMirror's keys.
Tests and docs follow.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A Changes tab in the bottom panel (ui/src/components/vcs/changes/): the
project's changed files from git.status in Staged, Changes and Untracked
groups, re-read on start, project open, gitChanged and vcs.refresh
(serialised). A checkbox per file and per group stages or unstages through
git.stage / git.unstage (a staged rename passes both paths); Space stages,
Enter or a double-click runs vcs.showDiff when provided, else opens the
file. A message box with Amend and Commit (also Mod+Enter) runs flushDirty()
first, cancels when a save fails, then git.commit and toasts the short hash.
All git calls go through runWaiting.
UI commands vcs.openChanges (Mod+Alt+G), vcs.commit (Mod+K, focuses the
message box) and vcs.refresh in a new Git menu group; gitChanged added to
EngineEventPayload. 19 Vitest tests; palette, menu and catalog tests follow
the new commands. Docs: architecture, gaps G8, Git parity row 4% (est.),
ui/tooling checklists, roadmap M4 row, ROADMAP depth ~5.4% and log, README.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
New crate lutra-vcs (L3): a safe git runner (argument arrays, no prompts,
GIT_OPTIONAL_LOCKS=0 for reads, timeouts 30 s / 120 s for hooks, output
caps, one spawn function for H1's kill-on-close helper), porcelain v2 / -z
parsers (property-tested), Repo operations (status, stage, unstage before
the first commit, commit and amend, show at HEAD/index, branches, checkout
with remote tracking, branch creation checked by check-ref-format) and a
.git poll (RepoWatch).
Engine: git.status, git.stage, git.unstage, git.commit, git.show,
git.branches, git.checkout, git.createBranch on pending outcomes, off the
engine lock; gitChanged after changes and debounced 300 ms on .git or
project changes; setting git.executable (section Git).
Tests against real temp repositories, engine tests through run_waiting,
docs (architecture, gaps G8, Git parity row, roadmap M4 row).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Both themes follow the README banner without taking it over: calm,
near-neutral surfaces (cream-tinted light, faintly plum-tinted dark),
the raspberry only as the accent, retuned syntax colours and the
terminal on the editor surface. Approved by the owner from before/after
screenshots.
New tokens `--lt-diag-error|warning|info|hint` (lint underlines, gutter,
tooltips, Problems icons) and `--lt-vcs-added|modified|deleted|untracked|
ignored|conflicted` (for M4.4), listed in `theme::DIAGNOSTIC_TOKENS` and
`theme::VCS_TOKENS`. Completion kind icons take the syntax colour of
their kind. The contrast test checks every new colour (4.5:1 text,
3:1 icons) in both themes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The first CodeMirror view and the first render of the editor area,
the palette and the settings dialog in a jsdom worker cost 0.3-0.6 s
once. The first test of EditorArea, language and modals paid it inside
its own 5 s budget and timed out under load. A beforeAll warm-up now
pays it once; no timeout changed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- Settings dialog: every string setting gets a text field with in-place
hints (quotes or spaces around a path, control characters, length);
keys ending in path/executable also get "Browse…" through the dialog
plugin's native picker (new desktop IPC pick_file). git.executable
from M4.1 gets the control without UI changes.
- settings.open {section?, query?} for agents and live checks.
- New keys editor.completion.autoPopup, editor.completion.delayMs and
editor.hover.delayMs; the assist module reads them live through
CodeMirror compartments.
- Tests: engine settings test, control/engine key lists, Vitest for the
controls and the live wiring. Docs: architecture, ui-parity, parity
Settings row, gaps.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
`--data-dir DIR` / `LUTRA_DATA_DIR` move settings, the recovery journal,
the rendezvous file and the WebView2 user data folder into one directory.
`--control PORT` without either uses `<temp>/lutra-control/<port>/`. The
SHA-256-checked Phpactor cache stays shared from the user's data dir
(`Engine::share_tools_from`). An isolated instance never forwards to or
registers as the user's main instance; `rendezvous::dir()` honours
`LUTRA_DATA_DIR` after `LUTRA_RENDEZVOUS_DIR`, so the CLI finds it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
New layer-0 crate lutra-proc: spawn(Command) puts the child into a
kill-on-close group. Windows: one job object per child with
JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE (windows-sys), nested jobs work.
Unix: a new process group plus a /bin/sh watchdog that kills the group
when Lutra's pipe closes (drop, kill, quit or SIGKILL of Lutra).
Child::kill and Drop take the whole group.
Phpactor (supervision spawn) and the php -v probe in lutra-lsp start
through it. Tests kill a parent hard and check that its child is gone
(with and without the parent in a group), plus kill and drop of a tree.
Docs: architecture "Child processes", G6 note.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Breadth recounted against the feature map (32/155), M3 measured at
~14 h of agent time (factor 0.17), full-parity hours re-scaled.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Engine (`cmd/lsp_nav.rs`, on the pending outcomes of 20d1d28):
- `lsp.definition` (F12) and `lsp.references` (Shift+F12, sorted, with
line previews) return project-relative locations; locations outside
the project, such as PHAR stubs and symlink escapes, are dropped.
- `lsp.prepareRename` uses the word at the cursor when the server has
no prepareProvider.
- `lsp.rename` (F2) applies the workspace edit (`lsp_nav/edit.rs`):
1. Check everything first: inside the project, ranges fit (UTF-16,
CRLF), open buffers unchanged since the request, no file
operations, no incomplete edit.
2. Write closed files atomically through the VFS, restoring earlier
writes when a later one fails.
3. Change open buffers through `buffer.edit` (dirty, undoable).
4. Send each written file to Phpactor as didOpen/didSave/didClose
plus didChangeWatchedFiles; without this its index kept the old
names. Then the summary notification `notification.lsp.renamed`.
UI (`components/editor/nav/`):
- Mod+click goes to the definition, with a pointer cursor while Mod is
held.
- A location picker for several definitions (exclusive modal).
- A References tab in the bottom panel, grouped by file.
- An inline rename field with a use/file count (exclusive modal).
- `BufferSync.beginUndoableRemote` puts the engine's rename edit into
the editor history as one undo step per buffer.
- Catalog strings and tokens only.
Fake LSP server: `--script FILE` with scripted capabilities and
answers (additive next to M3.4's arms).
Tests:
- `crates/engine/tests/lsp_nav.rs` (fake): definition; bad positions;
references; prepareRename; a multi-file rename incl. a closed CRLF
file; refusals for outside the project, a bad range, a stale buffer,
bad names and no server.
- The ignored real-Phpactor test covers definition, references and a
rename and back across 3 files.
- Vitest `ui/tests/nav/`.
Live (Phpactor 2026.06.25.0, Windows, port 7935, tick on):
- definition 93 ms cold / 7-18 ms warm
- references ~140 ms
- prepareRename ~11 ms
- rename 28-59 ms
- index follows written files in 140 ms
- Phpactor 57 MB working set, ~1.6% of a core while ticking idle
Gate: 13 steps, 197 s, Vitest 484 + 1 skipped.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Engine (crates/engine/src/cmd/lsp_assist.rs), on M3.5's pending outcomes:
- lsp.completion {id, position, triggerCharacter?}: items with label,
kind, detail, Markdown documentation, insertText, textEdit,
additionalTextEdits, sortText; sorted, capped at 500 (cut lists are
incomplete), snippets turned into plain text.
- lsp.hover {id, position}: Markdown contents and range.
- lsp.signatureHelp {id, position}: signatures with UTF-16 parameter spans.
- The request is queued after every didChange; the answer is converted
in the reply callback, off the engine lock. Positions are checked
against the buffer. Server strings and lists are capped.
- lutra-lsp-fake answers completion and signature help.
Editor (ui/src/components/editor/assist/):
- Completion source with Lutra's triggers (identifiers, $, ->, ?->, ::,
namespace \; not in strings or comments unless asked), the server's
ranking as boost, text edits and imports applied in UTF-16 (CRLF too),
Lucide kind icons.
- Hover documentation (350 ms) and editor.quickDocumentation (Mod+I).
- Signature help on ( and , following the cursor; editor.parameterInfo.
- editor.complete.
- Lutra's own Markdown renderer without HTML (XSS-tested), tokens only.
- Requests wait for the buffer sync to be idle and use runWaiting.
- New dependency @codemirror/autocomplete (MIT, already transitive).
Tests: 6 engine tests against the fake server, 9 unit tests, an ignored
real-Phpactor latency test, 29 Vitest tests; palette and menu tests list
the new UI commands.
Measured with the real Phpactor (Windows 11, debug build, 25 ms tick):
- Completion 61-109 ms while typing (median 76 ms; ~107 ms in the app).
- Hover and signature help ~16 ms median.
- A useful list 2.3 s after opening a file in a 20-class project, ~65 s
for 2,000 classes (indexing).
- Phpactor 56-71 MB working set, ~6% of one core while typing.
Live-checked in the app on port 7934. Docs: Code completion 0% -> 5%
(est.), feature depth ~4.1% -> ~4.6%, breadth 26/155, architecture, G6,
ui-parity, language-parity, roadmap, README.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Step 1 of M3.5: the shared mechanism. M3.4 and M3.5 build on it.
- Engine: `Outcome.pending: Option<Pending>`. `Pending::new(rx, timeout,
finish)`; `Pending::wait()` is called without the engine lock and
returns at the answer, a dropped sender or the deadline (timeout + 1 s).
`Engine::resolve(answered)` then runs `finish(state, reply)` inside the
guard, under the lock. `run_waiting(lock, cmd, params, publish)` does
all three steps for hosts.
- Hosts: `Host::run`, `testkit::EngineBackend` and the control test
backend use `run_waiting`.
- New IPC `engine_execute_waiting` (`#[tauri::command(async)]`, off the
main thread) with `runWaiting()` in `ui/src/ipc.ts`. Only `lsp.*`
requests use it.
Ordering guarantee:
- `engine_execute` stays synchronous on the main thread, so ordinary
commands (`buffer.edit`) still run in call order.
- The order towards the server is fixed under the engine lock:
`buffer.edit` queues its didChange on the session's FIFO queue before
it returns, and `lsp::submit` queues the request on the same queue.
A request therefore sees every edit whose `buffer.edit` returned
first, and the UI awaits the sync's `idle()` before sending one.
Failures:
- A stall is caught by the request timeout, with the deadline as
backstop.
- On restart, close, quit or crash the request is dropped or resolved
as stopped, so the waiter gets an error, never a hang.
Tests: `crates/engine/tests/pending.rs` (answer, lock free while
waiting, dropped sender, deadline, resolve, lsp.restart while a
request is pending) and Vitest for `runWaiting`. Gate: 13 steps,
321 s, Vitest 443 + 1 skipped.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- One Phpactor per open project on its own session thread, started when
the toolchain is ready; ordered document sync from buffer.edit and the
pump; lspStatus, diagnosticsChanged, diagnostics.list, lsp.status,
lsp.restart; app.quit stops the server synchronously.
- Phpactor 2026.06.25.0 on Windows: keep-alive $/lutra/tick (its event
loop only runs on stdin input), in-process diagnostics and a polling
watcher through initializationOptions (amphp subprocesses fail), 500 ms
shutdown timeout.
- Editor lint extension (underlines, gutter dots, hover; tokens only) and
a Problems tab in the bottom panel; problems.open Mod+Alt+P.
- Tests: engine tests against the fake server (incl. sync proptest), an
ignored real-Phpactor test, a TCP test, Vitest for lint and Problems.
- Docs: architecture, gaps G6, parity (Inspections 4% est.), ui-parity,
roadmap, ROADMAP.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- crates/terminal: portable-pty sessions (ConPTY on Windows) with reader,
writer and waiter threads, UTF-8 chunking, a 1 MiB output buffer with
backpressure, a non-blocking input queue, resize, kill and exit codes;
default shell pwsh -> powershell -> cmd on Windows, $SHELL or /bin/sh.
- Engine: terminal.create/input/resize/close, terminalOutput (capped per
terminal and per pump, round-robin) and terminalExited through the pump;
terminals close with the project and on app.quit.
- UI: Terminal tab in the bottom panel (tabs next to Find), xterm.js with
the fit addon, sub-tabs, copy/paste, a focus rule that leaves plain Ctrl
keys to the shell, terminal.open (Mod+Shift+T), --lt-terminal-* ANSI
tokens in both themes (text colours AA) and a 4.5:1 minimum contrast.
- Tests: real-shell crate tests (UTF-8, backpressure), engine and TCP
control tests, Vitest with a mocked xterm; live check on port 7936;
docs and parity rows.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Autosave saves dirty buffers when the window loses focus (DOM blur and
visibilitychange), when the active tab changes and after
editor.autosave.idleSeconds (default 15) without an edit; three settings,
all on by default. flushDirty() in ui/src/stores/autosave.ts is the one
save-all-dirty-and-wait entry point for later deployment, run and
terminal features: it waits for pending buffer sync, then runs
file.saveAll {skipConflicts: true}; one toast per failed file.
Engine: file.saveAll takes skipConflicts and returns skipped; Buffers
tracks buffers in conflict with their file and the hash of the last
read/written content, so our own save reported late is not a conflict.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The --wait end-to-end test hit its 20 s wall-clock deadline under
parallel-build load. It now waits on the backend's bufferOpened event
and on the process exit through channels, with a generous 120 s limit
that a passing run never approaches. The single-instance control tests
use a 60 s timeout instead of 10 s. The other CLI tests already wait on
the process without a deadline.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- crates/mcp (L5): JSON-RPC 2.0 over stdio, dual era: MCP 2026-07-28
(per-request _meta, server/discover, -32022) and legacy initialize
(2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05). Tools list_commands,
execute_command (app.quit only with confirm: true), screenshot (image
content), read_buffer, get_events (ring of 1000 events via
events.subscribe); resources lutra://buffer/<path> for open buffers.
Engine errors become tool errors with the engine code. Lines capped at
16 MiB, guard around every request, parser and tool args fuzzed.
- lutra mcp [--port PORT] [--no-start] in apps/lutra-cli: connects through
the rendezvous file and token, or starts Lutra.
- Engine: read-only buffer.list command.
- Tests: protocol units + proptest fuzz, integration over the token
listener, stdio end to end. Docs: architecture (MCP), G7, ROADMAP.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>