Zmiany
Ten sam tekst, który widnieje w oknie aktualizacji aplikacji — tutaj w całości i bez instalowania czegokolwiek. Najnowsza wersja u góry. Bieżąca, wraz z sumą kontrolną, stoi na stronie pobierania.
Uwagi istnieją po niemiecku i po angielsku; pozostałe cztery wersje językowe tej strony pokazują tekst angielski.
The menu bar popover carried the same details as the main window — rate, time remaining, forecast and window end. At 380 points wide that wrapped across several lines.
It now shows only the label, the bar and the percentage. Everything else is unchanged in the main window and the usage window, where there is room for it. The switches for paging and for the trend remain in both places.
The display read “5 days left” while the quota was due to reset in three — a day and a half off.
The reason. AItention detects a reset by the value dropping from a noticeable height to almost nothing. Until now every such drop counted, and the most recent one was used. But a single month produced five of them, and three had other causes — a switch to paid credit, a second subscription.
Now the rhythm decides. A drop only counts as a reset if there is a second one a week apart. If there is none, the display shows nothing rather than a figure that is demonstrably wrong.
There is a price, and it belongs here: after a fresh install it takes until the second observed weekly boundary before a day count appears again. We prefer a missing figure to a false one.
A second subscription used to show “0 %” — which reads like a measurement. In truth nothing had been measured at all.
The reason lies with the source. Claude Desktop only records usage for the account it is currently signed in to. A second subscription appears there only once you sign in with it — until then there is simply nothing to show.
Instead of a zero you now get the fact: “Not measured since … — Claude Desktop only measures the account it is signed in to.” In the trend, curves without data points are dropped from the legend rather than sitting there as an entry with no line.
With a single subscription nothing changes.
The “Combined” heading is gone again. It promised a summary and showed the figures of a single account — a label that was simply wrong.
Each set of bars now carries the name of the account it belongs to, and you page through them with ← and →. ↓ lays all accounts out underneath each other, ↑ takes it back. The trend has arrows of its own, so you can hold one account's curve beside another's bars.
And an empty chart now says why it is empty. The curve covers the last five hours; an account idle for days has no point in it. Previously you saw bare axes, which looked as though something had broken.
With a single subscription nothing changes: no heading, no arrows.
Two levels, both remembered: one click on the people icon shows your accounts separately, one click on the chart icon puts the trend underneath. Wherever you leave the switches, they stay — including in the menu bar popover, which shows the same strip.
Collapsed it reads “Combined”, with the figures of the account you are currently working with. Not a sum of the percentages — 8 % on one subscription and 40 % on another are shares of two different quotas; adding them would produce a number that means nothing.
An account that has been idle for days says so. It keeps its row, but dimmed and with the reading's age beside it, rather than showing an old figure that looks current.
With a single subscription nothing changes: no heading, no accounts switch.
Since the last release AItention keeps two Claude subscriptions apart. Now you can see both: two sets of bars in the usage window, the account you are currently working with first.
With one subscription nothing changes. A heading above a single bar would be a distinction without a second side.
The heading is also the name field. Click into it and type “Personal” or “Work” — the name stays on this Mac and is never sent anywhere. Without a name the accounts read “This account” and “Other account 1”.
There is a reason you name them yourself: the only name Claude keeps is one we must not show you. It contains your email address, and AItention promises you under “Application” that it reads neither address nor identifier from that file. A name you choose is the better one anyway.
When a session starts subagents — for a code review, say — and its own turn ends, the row used to read DONE while those agents were still running. We measured up to three minutes of the display claiming there was nothing left to do.
It now says the session is waiting for its agents. A question to you still takes precedence: if the session is waiting for an answer, that is what you see.
If a session fails before it begins — a folder that no longer exists, for instance — the row carries a warning mark and the reason appears in the tooltip. Previously it looked like any other.
If you use two Claude subscriptions, usage and quota were computed from both at once. A single reading from the other account could shift the time window by more than three hours. AItention now uses the account you are actually working with.
Until now we inferred your quota reset from the readings. That goes wrong when much time passes between two of them — overnight it was an hour and a half off from what Claude itself showed. Where Claude states the time, we now take it.
The rule about which files AItention reads at all now applies equally everywhere — including places that previously checked only the file name.
This release changes nothing you can see. It sharpens how AItention decides which files it reads at all.
AItention reads the records that Claude Code and Codex write to your disk. Which files count as such records is now decided in one single place in the program instead of six. A planted file that merely poses as a record is turned away just as strictly everywhere — previously three of those places applied a weaker standard.
Exploiting it would have required someone who can already write inside your user folder. We still think it is worth a release: a rule that holds in one place and not in the next is not a rule.
A check in the build now makes sure it stays that way.
In Settings under “Application” you now decide whether AItention shows your Codex sessions. From this release the default is off.
With the switch off, AItention does not even read Codex' files: no session in the list, none in “Previous sessions”, none in a counter and none in a group total. Usage and quota come from Claude either way.
“Stop showing” used to last forever. Anyone who cleared away a dormant session and later resumed it searched in vain — it stayed hidden even though it was running again.
Now the hiding ends as soon as the session runs again. The button does what it promises: tidy up, not hide for good.
With a window open — the introduction on first launch, for instance — an update could stall silently: “Ready to install”, one click, and then nothing. Closing the window later did not catch up, and you stayed on the old release without noticing.
This mostly affected people who had just installed AItention. Fixed.
The button in the hook notice responds at once instead of after a few seconds. Usage figures now say when they are old, and stop projecting into the future. And at larger text sizes nothing gets cut off in the switches any more.
Resume a session while it is still running and, for a moment, there are two processes for the same session. AItention could not cope with that and quit — without a message, the window was simply gone.
This is fixed. Of two processes for the same session, the one started last now counts — the one you are actually working in.
The same pattern sat in a second place: loading your federations. There, too, a duplicate entry can no longer end the app.
The name in the disk image window sat at the top — where the Finder places items that have no fixed position. Anyone who shows hidden files saw the image's helper folders sitting over the lettering. The name is now at the bottom.
Nothing changes in the app itself.
Nothing changes that you can see. This release tidies up in places you only notice once they are wrong.
The instructions for removing the status hooks and for running diagnostics named the “Applications” folder by a fixed name. They now read it from the app itself — rename it or keep it elsewhere and you still get the path that applies. The same goes for the note about how hook entries are marked: it now names the marker that is actually written.
The address of the update feed sat in four places: once where it is queried, and three times in texts describing it. Now it sits in one place and the texts read it from there. What you see is the same as before — it just cannot drift apart any more.
The button used to keep only the Mac from sleeping — the display still went to sleep, and the screen lock followed. From the outside that looks like a switch that does not do what it says, and that is exactly how it was reported to us.
Both now stay awake while the switch is on, so the lock does not kick in either. A closed lid still sleeps; no app can prevent that. As before, the switch is not remembered: it ends when you quit AItention, so nobody keeps their Mac awake all night because they forgot it the day before yesterday.
If you entered a program under “Run on state change”, the About window now shows what actually ran: time, state, the command with its arguments — and, more importantly, the reason when one could not start. That is what the list is for: the case of “I entered something and nothing happens”.
The list covers the current run of the program and is deliberately not saved — command arguments can contain paths from your projects, and those do not belong in a file that sits around for years.
The “Access” section under “About” still said AItention only reads files. Since it became possible to start a program on a state change, that was too narrow. It now says what is true — and that only what you entered and approved individually will run.
When a session changes state, AItention can run a program — “when waiting, then …”. A sound, a message to another tool, a script of your own: you enter the command, confirm it once, done.
This is the first place where AItention runs an outside program, and it is built accordingly. There is no default: without an entry and without your confirmation, nothing runs. The command does not pass through a shell — nothing is substituted, nothing appended. And the confirmation is tied to the exact wording: change the command by a single character and you have to approve it again.
“Large” now enlarges both. Large text in tight rows looked cramped, so spacing and row heights grow with it.
A button in the status bar opens your mail app with a prepared message. It carries the version and your macOS version — nothing else. No project paths, no session names, no file names. If no mail app is set up, the address goes to the clipboard instead of the click doing nothing.
Mute a state and it no longer chimes either.
At “large” the header can look cramped if you deliberately make the window small: the minimum width does not grow with the text. Four fixes were tried and discarded because none of them worked — better to ship nothing than something that only looks like a fix.
The reason for this release is not a new feature. AItention reads files other programs write — transcripts, logs, plan details. In four places a number from those files went into a calculation unchecked, and on a nonsensical value that calculation does not return a wrong result: it halts the program.
Three of the four sit on paths that run on every pass. Because these files are read again and again, a single corrupted number would not have ended the app once — it would have made it permanently unopenable until someone repaired the foreign file by hand. None of them showed up in normal use; they were found by looking for them. All four are reproduced and fixed.
Small, medium, large — across every window at once. The menu bar symbol deliberately does not follow: the bar dictates the height there.
You now choose which states AItention speaks up for — all eleven are selectable instead of a fixed four. And you can silence individual sessions or whole projects without silencing everything else. The default is unchanged from the previous behaviour.
A button next to the mute switch keeps the Mac awake while a session is working. It is deliberately not remembered: a switch that survives a restart keeps the machine awake all night because somebody forgot it the day before yesterday.
When the five-hour window resets. The remaining time was already in the popover; the clock time now sits beside it — 34 min left (18:00). Plus a notification when a reset is actually observed, not at a calculated moment. The third sound for it is set to silent; choose one if you want one.
Your optimal daily usage. Next to the weekly bar you now see where you stand against it: Left for today — 13 % or 15 % over the daily pace.
The menu bar symbol is configurable. Four checkboxes decide what it carries. The width limit is enforced rather than assumed: if not everything fits, the least essential figure drops out instead of the symbol overflowing the bar.
Click a dormant session to resume it. You used to have to copy the command out. One click now does it — including under “Previous sessions”. It works with any terminal that registers as a handler, and needs no automation permissions.
A state of its own: “Waiting for subagents”. Muted green, its own symbol — and the row says what is being waited for. Before, it looked like ordinary work.
The small symbols in the list carried their meaning only for those who already knew it. 53 were counted, 29 of them say something — all now have help text. Counting turned up two real gaps: the state symbol on the task list, and a clickable marker that never said anything would open.
The quota breakdown also says whose quota it shows: seven of the breakdowns come from Claude data alone, with no Codex in any of them. Anyone using both could otherwise have read the figure as a combined total.
The projection was noise. 2.66 hours extrapolated to a week produced 632 % — a number that looked like a statement. Now an eighth of the window must have passed before one appears at all. And “exhausted 11:47” read like the past; the calendar day now decides.
The choice between quota, tokens and money used to sit in settings. Anyone who did not know it was there never saw an amount. It now sits in the list header, right next to the counters — the grouping control moved into a dropdown to make room.
You can also choose which of the three figures the row shows: what the provider billed, what the same work would have cost through the API, or what every single token would have cost without caching. The usage window shows quota, tokens and money side by side, each with its own checkbox.
With many concurrent sessions the window could freeze for seconds. The cause was how the list was built: groups and rows nested inside each other, which made the effort grow disproportionately with every row. The list is flat now; measured, it copies 40 % less while doing more layout work.
The token total in the usage window was more than twice what it should have been — one answer is written as several lines in the transcript, and each carried the same usage figure. A corrupted line in a transcript could also terminate the application, and a row could disappear from the list when a project name contained a vertical bar. All three fixed.
Your token figures will get smaller as a result — they had been more than twice as high since 25 August 2026. That is not a regression, it is the correction. The first time you open the usage view, the application rebuilds its usage store once, in the background.
Every session now carries its cost. Three times over, because there are three different questions behind it: what your provider actually billed, what the same work would have cost through the API, and what it would have cost without the cache — that is, had you paid for every single token separately. The third number typically runs four to seven times the second. That is exactly its point: this is what the cache saves you.
The prices are derived and verified, not estimated: Claude Code writes its own cost figure at the end of each session, and the table is checked against it. Where no price is documented for a model, AItention shows tokens instead of money — better no number than an invented one. You always see how old the prices are, and you can override them per model.
While a session is still running, the figure reads “at least”. Not every model call lands in the transcript; the running number is a lower bound and is labelled as one until the final figure arrives.
Every row shows what it is working with: the model, coloured by family, and the effort level as bars beside it. If a session switches mid-run, the row shows the current state and the expanded view the breakdown. In the list you can switch between quota, tokens and money; on a flat rate the quota comes first, with pay-as-you-go the money. Your plan appears under “Application” and in the usage window — and only the plan fields are read from the configuration, no address and no identifier.
When you hand a task from one session to a new one, the data holds no trace of it — no field connects the two. The new “Copy as subtask” button lays that trace: it copies the start command together with the task text, and AItention recognises the new session as soon as it runs. Both then appear under Group — lead session on top, with completed tasks, waiting sessions and the cost of the whole plan in the heading.
You can also combine sessions yourself: ⌘-click several rows and name them. Where the trace is missing, AItention will at most suggest a group — it never assigns one without your click.
If a session has a goal, it takes the place of the tool name, with progress and elapsed time. For Claude Code, which has no goals of its own, you can set one yourself — budget included.
Some sessions resume on their own because a background task finished. With several of those running you used to be buried in notifications. Under “Alerts” there is now a switch: turned on, such a session only reports when it needs an answer or is done. You can also set a cost limit per session — AItention stops nothing, but it knocks in time.
The token counts in the usage window were more than twice what they should have been. One reply appears as several lines in the transcript, each carrying the same usage figure; every line was counted. The proportions in the rankings held, the absolute numbers did not. And the usage window claimed the plan was not available locally — which stopped being true once AItention read it.
Ten sections in one popover were taller than some screens: on a smaller MacBook the lower half was cut off — licence, updates, language — and nothing scrolled. Settings now open in their own window with four tabs: List, Alerts, Licence, Application. Each tab fits any screen on its own, and where it does not, it scrolls.
Reach them with ⌘, as in any other application, from the gear in the main window, or from the gear in the menu bar panel — the latter also when you run AItention without a Dock icon. Language and the introduction now live under “Application”.
The counter labels — WAITING, ACTIVE, DORMANT — looked stretched. They now use normally proportioned letters with a little more spacing. In a narrow window the grouping switch gives way instead of pushing the counters out of the row. And the “Settings …” and “About AItention” menu entries finally do what they promise.
The compaction hint read “erfahrungsgemäss”. The correct German spelling is “erfahrungsgemäß”. Nothing else about the application changes.
If you are on 1.8.0, there is no reason to update other than this one.
A new switch sits left of the grouping control. It turns off notifications and sounds without touching your settings — unmuting restores exactly what you had. Going into a meeting no longer means flipping three switches and guessing afterwards.
The state is visible without opening a window: the menu bar icon carries it. A mute you forget would be worse than none.
What keeps running: the counters, the badge — and forwarding to a configured address. That goes to a machine, not to you; stopping it would mean losing events with nothing to catch them. The note is at the switch and in the settings.
If you run Codex through OpenAI's application, your sessions used to be filed under "Visual Studio Code" — even when Visual Studio Code was not installed. Codex Desktop ships a VS Code core and reports it as its surface; which program is running is stated elsewhere. AItention now reads that.
Sessions therefore appear under the name of the application they run in, with its icon — in the list, in the "Previous sessions" window and in the grouping by application. Nothing changes for Codex in a terminal or in Visual Studio Code.
Finished Codex sessions appear in the "Previous sessions" window alongside
those from Claude Code — with title, project, application and the right
command to continue: codex resume rather than
claude --resume.
If codex is not on your path, the copied command carries the full
path to the program — it still runs.
A Codex session calls itself "Codex Desktop" — and was therefore given Claude's name and Claude's icon. It now carries the icon of the application it actually runs in. Also fixed: with two tools present, the fourth grouping tile was cut off.
AItention now also shows Codex sessions: title, project, state, context and output tokens — alongside your Claude Code sessions in the same list. With both running, a fourth grouping by tool appears.
Without touching your Codex setup. Codex keeps a record of its own per session; AItention reads it and changes nothing. Codex states its context window itself — so the compaction warning is read there, not estimated.
The file contract AItention draws its information from is now published: aitention.app/schema/status-v1.json. Any tool that can start a program on events may write a status file and then appears in the list — with no change to AItention. Three fields are required.
You can store an address in the settings. When a session then enters a state that needs you, a JSON message goes there — the same rule as for the notification. That connects home automation, a chat channel or whatever you like, without any foreign code starting on your machine.
Session name, project folder, application and state are sent — never
prompts, replies or paths. With no address entered nothing happens; the
field is empty as shipped. Unencrypted (http) only on your own
network, otherwise https.
As a session approaches compaction, its context figure changes colour. The threshold is not guessed but read from your own transcripts: the context drops sharply at a compaction, and the size just before it is the point in question.
The new „Waiting time“ tab in the usage window answers the question this program exists for: how long did your sessions sit there finished without anyone noticing? Total, average, longest — per day and per project, over seven, thirty or ninety days.
Recording starts with this version: the waiting time is in no file that existed before. Only start, end, state and project are kept — no content.
The app redrew the whole list every second, even when nothing in it had changed and even when the window was not visible at all. Both are fixed: with seven running sessions AItention now uses about half as much, and with no visible window almost nothing.
The prompt search ran several times over every entry on each keystroke, which briefly froze the app. It now runs once per pause in typing, on prepared data — roughly twenty times less work.
The usage view showed how full the two rate windows are. The new „Consumption“ tab shows what filled them: output, input and cache, bars per day, rankings by project, application and model, over seven, thirty or ninety days. Counted from your own transcripts — none of it leaves the machine.
The short version also appears in the expandable statistics in the main window: seven days, the three figures, and the top five projects and applications.
"Where did I do this before?" — the „Previous sessions“ window now searches every prompt you have ever sent, across all projects. The hit leads to its session, with the resume command next to it.
In 1.1.1 the "Previous sessions" view could enter a layout loop: the window recalculated its arrangement endlessly, consumed a whole CPU core and stopped responding. It affected anyone who had opened that window. The cause is fixed, and a check in the build prevents that shape from returning.
If your app froze: it was us, not your machine. We apologise.
In 1.1.0 they sat as a tab inside the About window. That is the wrong place: an About window is a reference for the imprint and the data sources, not a working view. They now have a window of their own, reachable from the clock icon in the main window's toolbar and from the menu bar panel.
Plus a way in at the moment you need it: when the list is empty — after a restart, that is — a button there opens them.
Close an application or restart the machine and you want to continue with
claude --resume — but with many sessions you no longer know which
was which. The new Previous sessions tab in the help window lists them:
grouped by application or project, searchable, over seven days, thirty days or
all of them. Each row offers the complete command to copy.
That command now carries the project folder. Claude Code looks for a session
below the directory it starts in — without the leading cd the
copied command found nothing when run from elsewhere.
Until now a finished session was labelled with its folder name, so several in the same project read identically one below the other. The title is now taken from the transcript, which outlives the restart — in the ordinary list as well as in the new tab.
In the comfortable density the opening words of the last reply now appear at the bottom of the row. When something new arrives, the old text rolls out upwards and the new one rolls in from below. A click still opens the full text.
The movement runs exactly once per new message and then stops. A display that is permanently in motion costs CPU without pause — something we measured elsewhere and learned from.
Clicking the usage bar used to open a second window that had to be found, moved and closed again — too much effort for a figure you want to catch in passing. The history now expands between the bar and the session list, and collapses just as easily.
The pin in its corner keeps it open, across restarts as well. Without it, expanding is a question of the moment; with it, a setting.
The switch “Download and install updates automatically” was on — yet nothing was ever checked. The reason ran deep: the machinery behind it only came into existence when someone opened the settings. Anyone who never did was never offered an update, with nothing to hint at it.
Updating now starts together with the application, and its state is visible in the diagnostic output — what cannot be seen is never checked.
In rare cases the application could crash while reading session data. The cause was an instrumentation added in version 1.0.10 for troubleshooting: it wrote its results without protection while two read passes ran at the same time. The instrumentation is now guarded, and two passes can no longer overlap — which also avoids duplicated work.
It used to show when the window would be full at the current pace — even when that moment lay beyond the end of the window itself. “Full in 5 h 40” for a window that rolls over in three hours describes a moment that no longer exists. Now it first states how long the running window still counts, and only then, and only if the limit would genuinely be reached before that, the warning follows.
The update window appeared in English although it ships with 36 languages: the application had not registered German as an available language. Fixed. Its checkbox now also reflects the same setting as the switch in the preferences.
Checking for updates used to raise a second dialog with its own consent — it did not know about the setting and therefore showed it wrongly. Two switches for one thing means none. Only the one in the settings remains, and it is off by default.
Larger type, stronger bars, and the projection is now coloured according to where usage is heading. New for the five-hour window: it has no fixed reset — its values fall continuously as older usage drops out — so instead of a reset date it now shows how long it will last at the current pace.
Both windows sit one above the other rather than side by side — which makes them comparable and leaves room for what counts: how long the usage still applies, and what it will add up to at the current pace.
The projection uses the average since the last reset, not the pace of the last hour. The difference is substantial: one busy hour extrapolated over five days would produce figures beyond 200 per cent. And when the window will not last, what is shown is not the number but the moment — “exhausted Thu 14:00” says what to do.
The pulsing dot on a working session was drawn as an endless animation — on every frame the display produces, up to 120 times a second, without pause. On its own it accounted for by far the largest share of CPU use: measured at 37 per cent with, 2 per cent without. The dot still breathes, but in step with the display rather than in an endless loop. It looks the same; it now measures around four per cent.
Next to the seven-day usage you now see how long it still counts — “5 days left”. Eighty per cent is relaxed if the reset is tomorrow and tight if five days remain. The moment is derived from the history; until a week of it exists, nothing is claimed.
The display used to follow along every second so that entries like “waiting for 3 min” stayed current. But seconds are only shown during the first minute — after that the same picture was drawn fifty-nine times over. Each redraw does not end inside the application: it also occupies the system's compositor.
The clock now ticks every second only while seconds are visible somewhere, and every five seconds otherwise. Nothing changes on screen — a great deal changes in load.
With many sessions open and a long uptime the application used more CPU than it should — to the point of noticeable sluggishness. Four causes have been removed: language resolution ran for every translated string instead of once; a row's tooltip was built every second for every row although at most one is shown; the mapping from session to application walked the process tree on every pass; and the status files were all re-read every two seconds, including those of long-dormant sessions.
The application records when its interface stops responding. Until now that measurement also counted time while the computer was asleep — a night in standby appeared as a series of stalls that never happened. Only waking time is measured now.
The CPU time consumed is also noted. Only both numbers together mean something: whatever burns CPU is stuck in a loop, whatever does not is waiting for something. Nothing changes in day-to-day use — for us it is the difference between a lead and a false alarm.
A session can schedule a wake-up for itself and carry on unaided. Until now that looked like “waiting for you” — making it the one statement in this application you could not rely on. Such sessions now appear as Scheduled in a colour of their own, no longer count towards the badge and raise no notification. The tooltip says when they will speak up again.
What matters is how this is recognised: by the wake-up actually scheduled, not by what a session claims about itself in prose. A question asked and a failed turn are untouched — both need you, whatever arrangement sits beside them.
A session's most recent reply now appears in the tooltip of every row, in the compact density too, along with what the session is currently waiting for.
A session can wait for a condition — a pipeline to finish, an agent to report, a file to fill up. Until now that looked like any other work from the outside. The list now shows such monitors as a marker of their own, with their count; the tooltip names the condition and how long it has been waiting.
The distinction matters more than it sounds: a session waiting on an external condition does not need you — one that has asked a question does.
With many sessions open at once the application could reach a state it never recovered from: the list was recomputed more often than one computation took. It then stopped responding and could only be quit.
The cause has been removed. The grouping of the list is now recomputed only when something has actually changed — the sessions themselves, or your settings for grouping, sorting and filters.
In addition, the application now records stalls even when they do not end by themselves. Previously the most serious case was the one that went unnoticed.
In rare cases the interface could stop responding for a few seconds after a long uptime. One cause has been removed: the application could create its timers more than once. It now also records such stalls itself, so that any remaining case can be shown rather than guessed at.
After an update the application brings its status helper to the same version by itself. Previously the version installed earlier stayed in place — silently, which meant improvements to it never reached anyone who had already set the application up. The application icon is now generated at the sizes macOS expects.
The “About and Help” window has a fourth tab: whoever sells a program has to say who stands behind it — and nobody should have to look up a website for that.
One statement on the “About” page has also been corrected. It read “no network access”. Since the application can look for updates, that is no longer true, and the page now states exactly when it goes online.
The application can look for new versions by itself. You decide on first launch whether it may; you can change that at any time in the settings and check manually instead. Every archive is verified against a key built into the application.
Only your IP address, the application's own version and the system version are transmitted. No profile of your system configuration is sent, and no logs are kept of these requests.
AItention shows in the menu bar which of your Claude Code sessions is working, waiting, finished, or asking a question.