Commit Graph
160 Commits
Author SHA1 Message Date
Stefan Haller 2dc3690e50 [SQUASHED] resize-side-panels-by-dragging 2026-11-15 18:17:53 +01:00
Stefan Haller 276e5a3756 [SQUASHED] improve-auto-updates 2026-11-15 18:08:00 +01:00
Stefan Haller a50daae076 [SQUASHED] show-commit-msg-diff-for-amend-commits 2026-11-15 18:07:56 +01:00
Stefan HallerandClaude Opus 5.5 b9e0861dfc Show the current search match in full where it overlaps other matches
If the search string can overlap itself, as "aa" can in "aaaa", the
matches overlap too. A cell that is part of two matches shows as part
of the first one. If the second one is the current match, some of its
cells then show in the color of the other matches, and it is hard to
tell where the current match is.

Show a cell as part of the current match whenever it is.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:28:00 +01:00
Stefan HallerandClaude Opus 5.5 e64b209aed Speed up drawing a view with many search matches
If a search has many matches, scrolling the view becomes laggy. For
example, a search for "e" in a long branch log can find 44000 matches.
With that many, drawing a 100x40 view takes 40ms, where it takes 0.14ms
without a search.

For every cell it draws, draw looks through all the matches to see if
the cell is part of one.

The matches are sorted in the same order as draw visits the cells, so
let draw step through them along with the cells. It finds the first
match on screen with a binary search. Drawing that view now takes
0.14ms with or without a search.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:28:00 +01:00
Stefan HallerandClaude Opus 5.5 0bb4566554 Add tests for drawing search matches
No test checks yet which cells draw shows as search matches. The next
commit changes how draw works this out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:28:00 +01:00
Stefan HallerandClaude Opus 5.5 0d77b04db3 Don't show search matches and hovered hyperlinks in the inclusion gutter
If a view shows the inclusion gutter and is scrolled sideways, the
gutter shows the highlight of a search match that begins in the columns
scrolled off to the left. The same goes for the underline of a hovered
hyperlink.

Let draw check only the content cells against the search matches and
the hovered hyperlink, and pass the results to setCharacter. The gutter
cells pass neither.

Since draw now works out the content column of a cell once, and not
again for every search match, this also makes drawing with many search
matches faster. With 44000 matches, drawing a 100x40 view took 265ms
and now takes 40ms.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:28:00 +01:00
Stefan HallerandClaude Opus 5.5 5ee580b010 Add tests for search matches and hyperlinks scrolled under the gutter
If a view shows the inclusion gutter and is scrolled sideways, the
gutter shows the search highlight of a match that begins in the
columns scrolled off to the left. It also shows the underline of a
hovered hyperlink that begins there. setCharacter checks every cell it
draws against the search matches and the hovered hyperlink, the cells
of the gutter included. For a gutter cell, the content column it works
out is one of the columns scrolled off to the left.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:27:59 +01:00
Stefan HallerandClaude Opus 5.5 cccd088895 Add a benchmark for drawing a view with many search matches
If a search has many matches, scrolling the view becomes laggy because
every draw takes long. Add a benchmark for this, so that later commits
can show how much faster they make drawing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:27:59 +01:00
Stefan HallerandClaude Opus 5.5 e2418047df Let benchmarks use WithSimulationScreen
The next commit adds a benchmark that draws a view.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 11:27:59 +01:00
Stefan HallerandClaude Opus 5.5 14a36053e9 Unexport IsPasting
Nothing outside gocui needs to know about pastes any more.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 10:22:50 +01:00
Stefan HallerandClaude Opus 5.5 c28e3576d1 Drop pasted keys for views without an OnPaste handler
Every view that takes text has an OnPaste handler now, and views that
don't take text already ignored pasted keys. Make this a single rule.
While a paste is in progress, keys go to the focused view's OnPaste
handler or nowhere. This replaces the check in execKeybindings.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 10:22:50 +01:00
Stefan HallerandClaude Opus 5.5 0111d9bd61 Let views receive pasted text in one piece
Editable views receive pasted text as one key press per character, so a
newline or a tab in the text triggers the keybinding for Enter or Tab.
The commit message panel works around this by checking IsPasting in
these keybindings. This is fragile, and it gives the panel no way to
look at the pasted text as a whole.

Add an OnPaste handler to View. For a view that has one, collect the
pasted characters, newlines and tabs while the paste lasts, and pass
them to the handler when it ends. Drop all other keys of the paste. They
are unlikely to occur in pasted text, and dispatching keys like Esc in
the middle of a paste would run them as commands.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 10:22:50 +01:00
Stefan HallerandClaude Opus 5.5 dec9e49162 Add support for pasting text in integration tests
The commit message panel handles pasted text differently from typed
text (see ba6cfc1f85), but integration tests couldn't simulate a
paste, so this had no tests. Let tests replay the events that a
terminal sends for a bracketed paste: the start of the paste, a key
press for each character, and the end of the paste.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 10:22:50 +01:00
Stefan HallerandClaude Opus 5.5 044a827a3e Withhold paste events while input is blocked
Buffer the start and end of a paste along with the keys, and replay them
in the same order. This way lazygit still recognizes the replayed keys
as pasted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 18:49:59 +01:00
Stefan HallerandClaude Opus 5.5 1be1a5cbfd Add a test for pasting while input is blocked
While a long-running operation blocks input, lazygit buffers key events
and replays them when the operation ends. Paste events aren't buffered,
so they take effect right away. If the user pastes text during the
block, the paste has ended by the time its keys are replayed, and
lazygit treats them as typed keys. In a list panel, every character of
the text then runs the command bound to it. Without the block, lazygit
ignores keys pasted into a list panel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 18:49:59 +01:00
Stefan HallerandClaude Opus 5.5 2a39f2b564 Rename bufferedKeyEvents to bufferedInputEvents
The next commit buffers paste events in it too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 18:49:59 +01:00
Stefan Haller dd1ec8a56b Remove a stray comment line 2026-11-11 18:49:59 +01:00
Stefan HallerandClaude Opus 5.5 92525a2347 Scroll the commits panel sideways to a search match that was off screen
If a search match is in a commit below or above the visible area of the
commits panel, going to it with /, n or N doesn't scroll the panel
sideways to show it. The panel keeps the horizontal scroll position of
the previous match instead. Since this depends on whether the commit
was on screen before, it seems to happen only some of the time.

The commits panel renders only the lines on screen. So the search knows
where in a commit's line its match is only once the line is on screen,
and that happens after the search has scrolled the panel to it.

Scroll the panel sideways once more after rendering the lines that a
search has scrolled to. The same applies to the commits of a branch
or tag.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 20:14:38 +01:00
Stefan HallerandClaude Opus 5.5 a73278d246 Extract View.scrollSidewaysToSearchResult
A view that renders only the lines on screen is going to need it once
it has rendered the line of a match.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 20:14:38 +01:00
Stefan HallerandClaude Opus 5.5 8fb62f85b6 Keep the current search match when it is on the selected line
If the selected line has several search matches and n has gone to the
second one, a refresh makes the first match on the line the current one
again. The "x of y" status changes although the user did nothing, and
the next n goes to the second match on the same line once more. Focusing
the view again does the same.

If the current match is on the selected line, keep it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 19:54:00 +01:00
Stefan HallerandClaude Opus 5.5 4aed79b954 Keep the current search match when a view without a selection refreshes
If a view doesn't show a selection, for example a branch's commit log
in the focused main view, n and N step through the matches without
moving a cursor. A refresh then resets the search to the first match,
so the "x of y" status goes back to "1 of y", and the next n starts
over from the top.

Only reset the current match when a new search starts, and keep it when
the search runs again over refreshed content.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 19:54:00 +01:00
Stefan HallerandClaude Opus 5.5 c732aaf163 Choose the current search match after a refresh as after moving the selection
If the selection is between two search matches, moving it makes the
match above it the current one, but a refresh makes the match below it
the current one. So a background refresh changes the "x of y" status
and the highlighted match although the user did nothing. If the
selection is below the last match, a refresh makes the first match the
current one; n then skips that match and goes to the second one.

After a refresh, choose the current match in the same way as after
moving the selection. This makes the first match on the selected line
the current one, or else the last match above it. The same applies
when the focused main view renders its diff again.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 19:54:00 +01:00
Stefan HallerandClaude Opus 5.5 6878890b96 Give View.Search its own choice of the match to start at
A new search goes to the first match after the cursor. A search that
runs again because the content has changed uses the same rule, since
Search shares it with UpdateSearchResults. Choose the match in Search
itself, so that UpdateSearchResults can choose differently.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 19:54:00 +01:00
Stefan HallerandClaude Opus 5.5 6042e1c28b Restore the terminal if one of gocui's goroutines panics
A panic in the goroutine that polls the terminal for events leaves the
terminal in raw mode and on the alternate screen. The panic is then
hard to read, and the terminal needs a reset afterwards.

Guard this goroutine the same way as the worker goroutines. Guard the
goroutines that send a resize event too; they are unlikely to panic,
but this way all of gocui's goroutines are guarded, and a check for
unguarded goroutines doesn't need any exceptions.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 20:28:53 +02:00
Stefan HallerandClaude Opus 5.5 d8972194d5 Extract gocui's guard against panics in workers into a helper
The next commit uses it for gocui's other goroutines.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 20:28:53 +02:00
Stefan HallerandClaude Opus 5.5 94a3070f02 Time double clicks by when the clicks were read
gocui decides whether two clicks form a double click by the time it
handles them. If handling the first click keeps the main loop busy for
more than 500ms, a quick second click doesn't count as a double click.
The other way round, two separate clicks that wait in the event queue
while the main loop is busy count as a double click.

Compare the times at which tcell read the clicks instead. For events
replayed by integration tests, this is the time the test created them.
This way, a DoubleClick in a test no longer depends on how fast lazygit
handles the first click.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 14:17:47 +02:00
Stefan HallerandClaude Opus 5.5 5bc855415a Add a test for clicks that wait in the event queue
If the main loop is busy, clicks wait in the event queue and are then
handled right after each other. gocui decides whether two clicks form a
double click by the time it handles them, so two clicks read more than
500ms apart count as a double click.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 14:15:25 +02:00
Stefan HallerandClaude Opus 5.5 0855e981cf Remove the unused Timestamp of replayed input events
Every caller passes 0, and nothing reads it. The next commit makes
replayed mouse events carry the time they were created; a second, unused
timestamp next to it would only confuse.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 14:14:08 +02:00
Stefan HallerandClaude Opus 5.5 dc4fee296c Leave out the text of the rows of a rendering that states its lines
Under a diff renderer that states which diff line each row shows, such
as delta, the queries about the lines of the main view read the rows by
those records alone. Still, they took the text of every row as well,
and for a diff of 300,000 lines this was most of the time each of them
took. Moving the selection by change block runs two of them for every
key press.

Take the records of the rows first, and their text only if no row
states a diff line.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 08:41:50 +02:00
Stefan HallerandClaude Opus 5.5 3f64902a11 Collect the records of a line when the line has been written
Under a diff renderer that states which diff line each row shows, such
as delta, moving the selection by change block in a diff of 300,000
lines lags noticeably. One reason is that the queries about the lines
of the main view collect the records of every row from the row's
cells, going through every cell of every row. Under delta, a row has
about 130 cells.

Collect the records of a line once, when the write cursor moves on to
the next line, and take them from there. A line that is written to
again is read from its cells until it has been finished again.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-14 08:41:50 +02:00
Stefan Haller 96f93ec79d Show the diff view's narrow selection bar on the right edge too
This is an improvement for users who use a side-by-side diff renderer on
a very large screen; in this scenario it was hard to see which hunk on
the right side was selected.
2026-10-10 14:20:04 +02:00
Stefan HallerandClaude Opus 5.5 dd68e5644a Scroll a view sideways to show the search match it goes to
If a view doesn't wrap, a search match can be past its right edge, or
left of it once the view is scrolled sideways. Going to such a match
with /, n or N only scrolls the view vertically, so the match stays out
of sight. This matters most for a diff with gui.wrapLinesInDiffView set
to false, where a change is often at the end of a long line.

Scroll the view sideways if the match isn't on screen. Put the match a
third of the way across the view, so that some of the text before it
shows too. If the view can show the match without scrolling, go back to
the left edge instead. This applies to every view that doesn't wrap,
including the side panels.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:44:43 +02:00
Stefan HallerandClaude Opus 5.5 6da4f658d7 Don't leave a re-rendered diff scrolled further right than it reaches
The main view keeps its horizontal scroll position when a diff is
rendered again. If the new rendering is narrower, for example because
the only long line in it was just staged, the view can end up scrolled
past the end of every line and look empty. If one line still reaches
into the view, the view shows only a sliver of it, although the whole
diff would fit without scrolling.

Once a render has been read to the end, scroll the view back as far as
it takes to put the end of the widest line at the right edge. A long
diff that is read only in part is checked once the rest of it has been
read.

Nothing scrolls the main view horizontally yet, so this changes nothing
on its own. It prepares for scrolling the focused main view sideways
with H and L.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:44:43 +02:00
Stefan HallerandClaude Opus 5.5 abc16e904c Keep horizontally scrolled content out of the inclusion gutter
If a view that shows the inclusion gutter is scrolled horizontally, its
content is drawn over the gutter. The marker of a marked line is
overwritten, and the content starts the gutter's width too far to the
left. The draw loop skips the cells scrolled past the left edge only
until x reaches 0, but the content area starts at the gutter's width.

Nothing scrolls such a view horizontally yet. A later commit lets the
focused main view scroll sideways, and the gutter shows there while
building a custom patch.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:44:43 +02:00
Stefan HallerandClaude Opus 5.5 42f7bf66a6 Remove the unused View.Line and View.Word
Nothing in lazygit calls View.Line or View.Word; they came with the
original gocui code and have never been used. They are also the only
callers of realPosition. That function ignores the inclusion gutter when
it maps a view position to the buffer. On top of that, Word uses the
returned column as an index into the line's cells, and this goes wrong
for wide characters.

Remove them, together with realPosition and the indexFunc helper. This
leaves contentX as the only code that maps a column of the view to a
column of the content.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:40:23 +02:00
Stefan HallerandClaude Opus 5.5 fda5abdfb3 Account for the inclusion gutter when mapping view columns to content
Search matches beside the inclusion gutter are highlighted in the wrong
place, and hovering over or clicking a hyperlink there acts on the wrong
cell. The draw loop starts the content after the gutter, but the code
that maps a view column back to a column of the content only adds the
horizontal origin and ignores the gutter.

Add a helper that does both, and use it for search highlights, hover
and clicks.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:40:23 +02:00
Stefan HallerandClaude Opus 5.5 07995e630b Add tests for search matches and hyperlinks beside the inclusion gutter
If the inclusion gutter is shown, as it is in the focused main view
while building a custom patch, search matches are highlighted two
columns to the left of where they are. Hovering over a hyperlink
underlines the wrong columns, and a click acts on the cell two columns
to the right of the one that was clicked.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:40:23 +02:00
Stefan HallerandClaude Opus 5.5 e314ad884a Draw a blank for a double-width character cut off at the edge of a view
A double-width character that starts in the last column of a view is
drawn over the view's frame. One that is scrolled halfway out to the
left is skipped, and the column it reaches into isn't drawn at all. The
draw loop clips cells against the edges of the view as if every cell
were one column wide.

A terminal can't show half of a double-width character. So draw a blank
in the column that is on screen, in the character's colors, and let the
selection highlight cover that column like any other.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:35:25 +02:00
Stefan HallerandClaude Opus 5.5 bab90de2fd Add tests for double-width characters at the edges of a view
If a double-width character starts in the last column of a view that
doesn't wrap, its second half is drawn over the view's frame. If one is
scrolled halfway out to the left, the column it still reaches into isn't
drawn at all. This column then has neither the selection highlight nor
the line's background. Both happen in every view that doesn't wrap: the
side panels, and the main view with gui.wrapLinesInDiffView set to
false.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-10 13:35:25 +02:00
Stefan Haller 7aff6d7eae Give views a transient line flash
Actions that hand control to another application need visible
acknowledgement without moving a view's cursor or replacing renderer
colors. Reverse the narrow selection bar independently of selection
state, and clear transient flashes whenever the terminal UI suspends.
2026-10-05 11:55:14 +02:00
Stefan Haller 9fdefc418d Keep mouse gesture modifiers stable
Bindings match modifiers exactly, so a modified press must not turn into
an unmodified drag or release halfway through the gesture. Capture the
press-time modifiers once and carry them until the button is released.

This also makes unbound modified clicks no-ops instead of silently
invoking plain-click behavior.
2026-10-05 11:55:14 +02:00
Stefan Haller ef5f0dccfb Let mouse bindings work behind focused popups
Mouse events on views behind a popup are normally swallowed before their
bindings can run. Add an explicit early-dispatch opt-in for actions that
should remain live there, matching the phase where hyperlink clicks
already run.
2026-10-05 11:55:14 +02:00
Stefan Haller 23c0b40fce Separate redraws from view-line invalidation
A view can need repainting even when its cached wrapping is still valid.
Track that state independently so content-only flushes do not overload
tainted, whose only job is to request a viewLines rebuild.
2026-10-05 11:55:14 +02:00
Stefan Haller dc6ea4d515 Remove unused per-line highlighting
View.SetHighlight has no production callers.
2026-10-05 11:55:14 +02:00
Stefan HallerandClaude Opus 5 15532b74b9 Cleanup: remove error return value from Gui.SetRune, Gui.draw() et al
These always returned nil.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-10-05 11:55:14 +02:00
Stefan HallerandClaude Opus 5 770f788ef8 Mark the lines of a commit's diff that are in the custom patch
A patch built from what is on screen has to show what is in it, over the
diff those lines were taken from — which may be a diff renderer's
rendering of it, whose bytes are none of ours to touch.

So the marks are drawn in a gutter over the content, from the lines the
patch holds rather than from where they were drawn last. They are worked
out again whenever a pane's content settles and whenever the patch
itself changes. Working them out as the content settles keeps them right
across a renderer switch, a change of context size, or a walk through
the commits.

They are shown whenever the main view shows the diff the patch is built
from, whether or not it has the focus. The pane beside the diff previews
the patch all the while, and marks that came and went with the focus
would look like a bug while browsing. A diff of any other commit gets
none.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-05 11:33:11 +02:00
Stefan HallerandClaude Opus 5 394d91d147 Draw a gutter of inclusion marks over a view's content
The lines of a commit's diff that are in the custom patch being built have
to be shown as such over whatever a diff renderer made of that diff, whose
bytes we can't touch — and mustn't, since everything we know about a row is
keyed by where it sits in the content.

So the marks are a decoration drawn over the content instead: a column
reserved at the left of every line, blank but for the lines that are in,
with the content shifted along past it. Nothing about the content changes
but the width it has to wrap in.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-10-05 11:33:11 +02:00
Stefan Haller 32a9eda127 Replay withheld keys on a later pass of the event loop
EndBlockingEvents dispatches the keys buffered during a block from inside its
own call, so a keybinding handler runs in the middle of whatever the caller was
doing. If a caller ends the block partway through updating the screen, that
handler acts on state the caller has yet to finish writing.

No caller does that today; both of them end their block from a UI-thread
callback of their own, with nothing left to do afterwards. The commit after this
one adds a caller that can. It ends the block from a render restore, and a
render of the two main panes resolves that restore halfway through laying the
panes out.

Queue the replay through Update instead, so the buffered keys arrive on a later
pass of the loop, as they would have if the user had pressed them then. Input
stays withheld until that pass runs. Gui events are dispatched in preference to
queued work, so a key pressed in between would otherwise be handled ahead of the
keys buffered before it.

The replay's error now reaches the error handler along with every other
handler's, and EndBlockingEvents has nothing left to return.
2026-10-05 11:20:31 +02:00
Stefan HallerandClaude Opus 5 5d1489bc92 Copy the selected diff lines from the focused main view
The main view shows a diff renderer's picture of a diff, and that is not
what you want on your clipboard: a renderer may drop the +/- column, move
the line numbers into a gutter, group a hunk's deletions before its
additions, or leave lines out altogether. So copying takes the lines from
the diff itself, locating them by the identity of the selected rows.

Only the panel that produced the diff can produce it again, though: the
working tree's staged or unstaged side, a commit's, a stash entry's. The
new seam is there for that. It asks per file, so that copying three lines
of a commit's diff doesn't fetch the whole of it, and it will grow the
actions on a selection as staging and patch building arrive.

The clipboard gets the run of diff lines from the first selected line of
a file to the last, so that lines the renderer hid come along and the
result still reads as a diff. Headers count as selected lines too. A hunk
header names the first line of its hunk, so it is looked for the way a
line of the file is. A file header names no line at all, and a rendering
may draw it over any number of rows, so a selection touching one of them
takes the whole header.

As in the patch explorers, a selection that is all additions or all
deletions loses its +/- column, ready to be pasted into code. One that
reaches into a header keeps the columns, and what comes out is a patch
fragment rather than lines of code.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-10-05 11:01:24 +02:00