What's new

Every bugsTweet release, newest first. The notes are the ones that ship with each release.

bugstweet

The tool you add to your Flutter app. It builds tester apps with the reporter inside.

Latest … on pub.dev

bugstweet_reporter

The bug reporter testers see. The tool adds it to tester builds only.

Latest … on pub.dev

0.9.10 26 Oct 2026

When the app closes unexpectedly, the next start offers to report it; with Pro, reports also show the app's last internet requests and printed lines, a crash report shows the whole error trace, and developers can write to the tester from the report.

Details

Network and app log, a paid part: the phone keeps the app's last 50 HTTP requests (method, address, answer code and time; never headers or bodies) and its last 500 printed lines (`print`, `debugPrint`, Flutter's own error output). Passwords, tokens, keys and secret query values are hidden as they are kept, and the app's `redact` rule is applied. With a paid key the hosted service adds both to the issue, folded, newest kept when long; in free view, and with a GitHub key, a relay or the share sheet, they stay on the phone. Follows the tester's answer to "Remember my last 30 seconds"; `recordAppLog: false` turns it off. Pro
The app closed unexpectedly: while the app is in use, bugsTweet keeps its last seconds in the app's own files every two seconds (the screen and errors; with recording allowed also the steps, log and filmstrip). When a run ends while the app is in use (a crash, or the system stopped it), the next start asks "The app closed unexpectedly last time. Report it?" Report opens a report made from what was kept, with the last filmstrip picture. Every tester gets the card and the report; with a paid key the hosted service adds the whole trace of each error before the closure, or says to look in the device log when there was none. On in tester builds, off in debug runs; `reportCrashes`. Pro
Developers write to the tester, a paid part: a comment on a report that starts with "For the tester:" shows under that report in the tray, on every open report, not only Pending ones. The tester answers in their own words (or with a choice, when the message ends with "A / B"), or closes it with Got it. Other comments stay on GitHub. The hosted service reads all messages of the last 30 days in one go. At start, a card says "The developer wrote to you about #12. Read it?" when a message waits on a report this phone sent; Read it opens the tray, Later keeps the card away for that message. Pro
"Add to existing report" carries the ten-second clip too (with Pro). The filmstrip and the clip of an added report are now placed by the hosted service like in a new report, so free view leaves both out. Needs the service of the same day.
Tester builds use bugstweet_reporter 0.9.10: the crash card after the app closed unexpectedly, and with the hosted service the app's network and printed log, developer replies in the tray, and the clip on reports added to an existing issue.

0.9.9 26 Oct 2026

With Pro, reports name the exact code the tester had, say what is missing to repeat the bug, and carry the 10-second clip; two new commands prove a fix and find the taps that matter.

Details

The ten-second clip is a paid part, placed by the hosted service: with a paid key the issue shows the clip as before; in free view, and with a GitHub key, a relay or the share sheet, the clip stays on the phone, where the tester can still record and watch it. "What will be sent" names the clip and the filmstrip only when they are sent. Pro
Build receipt, a paid part: reports name the code the tester's build was made from (commit, uncommitted changes, flavor, bugsTweet version, widget list), and ask the agent to compare it with its own checkout before changing code, so files and lines match. The bugstweet tool adds it to every tester build; names and numbers only, no code. Pro
Ready to reproduce?, a paid part: reports list what the agent is missing before it starts, one plain line each: no taps recorded, steps that start part-way, taps on private fields, no app state, no note, a blurred area. When nothing is missing, it says so. No made-up score. Pro
Smart retest list, a paid part: reports whose code files changed in this build say "Maybe affected by this build" in the tray, even when no fix note was written, so they get retested too. Pro
Tester builds carry a build receipt: the app's commit, whether it had uncommitted changes, the flavor, the bugstweet version and a fingerprint of the widget list. With the hosted service, paid reports name them so the agent can check out the same code. Pro
With the hosted service, each tester build also sends the names of the app's Dart files that changed since the previous tester build (names only, never code), so testers' trays can mark reports whose files changed.
New command `dart run bugstweet verify <report> --test <file>`: after a fix, it runs the bug's test on the code the tester's build was made from (it must fail) and on the code now (it must pass), then posts "Verified fix" with both commits to the report. When the runs do not prove the fix, it says why and posts nothing.
New free command `dart run bugstweet shorten --test <file>`: for a failing bug test, it removes taps one at a time and keeps only those the failure needs (the test must still fail the same way), then writes the shortest test next to the original, which stays as it is.

0.9.8 26 Oct 2026

When one build fixes several reports, testers get one card to retest them all, and long text is no longer cut off on the phone.

Details

Several reports fixed in the same build make one card, "9 reports are fixed in this build. Retest them?": Show me opens the tray at Ready to retest, Later closes it for all of them. One fix keeps "#12 is fixed in this build. Try it?".
Text is no longer cut where the tester reads it: the whole report title on the retest screen and the fixed card; every change under "What changed" (it scrolls when long) and in the retest comment on GitHub; the duplicate card's title; the "What will be sent" summary; app errors; the screen and steps on the retest card. Typed answers and notes grow up to four lines. Tray rows show up to two lines of the title.

0.9.7 25 Oct 2026

The tray now sorts reports by what needs the tester first and says which build the phone is on. With Pro, the duplicate check and the agent's questions come from the bugsTweet service.

Details

The duplicate guard is a paid part, made by the hosted service: before a send, the app asks the service whether an open issue has the same first screen and app widget, and the service compares them (with a paid key; free view always answers no match). With a GitHub key or a relay there is no duplicate check. The app no longer reads issue bodies for this. Pro
The agent's cards are paid parts, read by the hosted service: the Actual / Expected / Fix to answer Go or Not quite, the agent's question, and "Fixed in build N" with its "Try it" card. The app asks the service for an issue's cards instead of reading its comments (with a paid key; free view gets none). With a GitHub key or a relay there are no cards. Pro
"Fixed in build N" is found on every open report, also one without a status label, in one call to the service (the retest list), and read the way people write it ("Fixed in tester build 35 (1792955626)"; the phone's own build number is used when both are named). The issue asks the agent to write the build like the "(build ...)" on its Device line.
The tray's Reported list comes in groups, so the tester sees first what needs them: Ready to retest (fixed in this build), Being worked on (the tester's answers to the agent first; also "Fixed in build N, not in your build yet"), Not started, and Done folded behind "Show done (N)". The tray says "You are on build N", and each fixed report says which build has the fix. A search still shows one list.

0.9.6 25 Oct 2026

What you check is exactly what is sent, pictures included. With Pro, the bugsTweet service now writes the steps, the scenario, the place in the code and the test draft.

Details

Privacy: what the tester checks is exactly what is sent. "The full issue" now shows the pictures exactly as they are uploaded (marks and blurs drawn in), next to the text. These pictures are made once and kept, so a retry after a failed send uploads the same bytes; changing a mark makes a new set. The kept pictures are removed with the report and after it is sent.
Hosted service only: a new report also carries its raw facts (steps, screens, marks, app facts; already cleaned by `redact`; no pictures), from which the service will write the paid parts of the issue. The service takes them out before the issue reaches GitHub and keeps nothing. Direct sending and relays are unchanged. Pro
The scenario (Given / When / Then) is a paid part and is now written by the hosted service, not by the app. Issues sent directly or through a relay no longer carry it; the report screen no longer shows it; "The full issue" says in hosted mode that the service adds the paid parts. The agent instructions read "a test that repeats the bug". Pro
File and line (where a widget is in the code) are a paid part and are now written by the hosted service, from the widget list the build tool sends it. The app names the widgets only: "in NextDoseCard" instead of "in NextDoseCard (lib/today/next_dose_card.dart:12)". The widget map in the tester file is still used to tell the app's own widgets from Flutter's. Pro
The other paid parts of a report are now written by the hosted service too: the tester's steps, the time-travel record with the filmstrip picture, the test draft, what the app knew, and the full phone condition. In hosted mode the app leaves a marker line where each goes and sends the facts they are made from; issues sent directly or through a relay no longer carry them. Errors, device and basic phone facts stay in every report. Pro
The issue title is the note's whole first sentence (up to GitHub's limit), not cut at 70 characters.
Secondary buttons such as Cancel and Close are solid, so the app or the tray list never shows through them.
Hosted builds (with a project key in `.bugstweet/key`) send the list of the app's widget classes with their file and line to the bugsTweet service at each run and build: names and places, never code. The service writes where each widget is in the code into the project's paid reports. If it cannot be sent, the build goes on and says so. Pro

Earlier releases (31)

0.9.5 25 Oct 2026

Privacy: a blur over any part of a label now hides all of that label's words. Before, blurring only an email in "Account: user@example.com" and pointing at "Account" still wrote the whole line into the issue, the test draft, the kept record and retests.
Privacy: `BugsTweetPrivate` around a section of a scrolling list (a sliver) is now blurred where it paints. Before, it was not blurred at all, not even a password field inside it. A private part that cannot be measured is blurred by what is inside it, or by all that is visible around it: more blur, never less.
Privacy: a private part the app moves or scales on screen (a Transform, a slide-in) is blurred where it is drawn. Before, the blur stayed at its unmoved place and the secret showed beside it.
Privacy: `redact` now also cleans error traces and the names of `appState` facts. Before, an email hidden in an error message could still be sent in the trace under it.
Privacy: the first-launch card and the tray switch now say what is kept: small pictures of the last 30 seconds and the last 30 taps. Before, they said "the last 30 seconds" for both, but taps had no time limit.
Privacy: a long shot reads the private parts in the same moment as each picture. Before, it read them after the picture was encoded, so a private part that moved (an animation) could be blurred where it went, not where the picture showed it.
A retried send never makes a second issue: before a retry, every bugsTweet issue changed since the report was made is checked for it, not only the newest 10. Before, ten or more newer reports could hide the issue an earlier attempt made.
A retry after editing a picture works with the relay and the hosted service: the edited picture is added under its own name instead of replacing the first one, which they never allow. Before, that send was refused every time. The earlier picture stays in the reports repository, and the tester is told.
The app reads every comment on a report's issue, 100 at a time. Before, only the first 100 were read, so on a long discussion the newest question, proposal or "fixed in build" message was not seen.
Privacy: in release builds every capture waits for the frame being drawn before it measures the private parts and takes the picture, so a blur sits where the picture shows them, also during a page transition. Before, only debug builds waited.
A report says when its picture may be missing part of the screen: under a picture of a screen with a map, web page or video (which phones may leave blank in a capture), the issue now says so. Before, the blank area was not explained.
The test draft compiles when it taps an app widget by type: it finds the widget by its type's name instead of naming a type it never imports. Before, `find.byType(MedicationDial)` failed with "Undefined name".
A widget name written in more than one place is given as a choice: `PriceTag (one of: lib/cart/price_tag.dart:12, lib/product/price_tag.dart:30)`. Before, the places were joined by "|" and could be read as certain.
Honest sending: when a send replaces a picture that an earlier, half-failed attempt already uploaded, the tester is told that the earlier version stays in the reports repository's history (`DeliveryResult.notice`). Before, the code claimed the old picture was gone. Every automatic blur is drawn into the picture before its first upload (now locked by a test).
`BugsTweetConfig.logoColors`: the logo in Purple (the default), Teal, Blue, Coral, or seven colors of your own (`BugsTweetLogoColors`). The logo is now drawn from its vector with the logo kit's exact color recipe, at any size, instead of a fixed purple picture.
Safety: making a tester build never changes your app's own files. A link to a file is copied as a real file, and a file reached through a link to a folder elsewhere is not changed: the build stops and says which link to replace. Before, the changes for the tester copy could go through a link into your app.
`-tlib/main_dev.dart` and `-t=lib/main_dev.dart` (the start-file option with its value attached) are refused like `-t lib/main_dev.dart`. Before, they slipped through and the tester build had no bug button.
`build ios --simulator` works: the result is collected from the simulator's own folder, and an older tester build is replaced only when a new one is really there. Before, it looked in the device folder, deleted the previous tester build and stopped with an error.

0.9.4 23 Oct 2026

Long shots reach the end of long pages: up to 60 screens instead of 10, with each screen kept compressed so memory stays low. A list under a collapsing header or tabs (NestedScrollView) is now walked, and a page that is still loading gets a moment to grow before the long shot stops.

0.9.3 23 Oct 2026

Tapping the preview after a screenshot opens the report screen ("Tap to report"); marking it up is one tap away.
Delete on the report screen, after a confirm step.
The logo by the Tray title and by "What's wrong?".

0.9.2 23 Oct 2026

The bugsTweet logo is the capture button, and marks the first-launch notice and the "Report this?" card. The timer and clip countdowns show their seconds over the dimmed logo (red for a clip).
`GitHubDelivery.hosted`: send reports through the hosted bugsTweet service with a project key. No GitHub key and no relay in the app; the issues are written by bugsTweet[bot].
Other apps' setups: a relative signing key path in android/key.properties, relative paths in build options (`--split-debug-info`, `--dart-define-from-file`, `--export-options-plist`) and flavor iPhone settings files (Info*.plist) now work in tester builds. After a build without `--build-number`, a tip says to give tester builds their own.
`init --hosted` and `.bugstweet/key`: send reports through the hosted bugsTweet service with a project key from api.bugstweet.com. The key file is added to .gitignore and put into each tester build; no key in the command.
The store-build guarantee also checks pubspec.lock, so the reporter is refused when it comes in through a local package or pubspec_overrides.yaml.
Builds with the Flutter that belongs to the Dart running the tool, so `fvm dart run bugstweet` uses the FVM version. A missing Flutter gives a clear message instead of a crash.
Apps in a pub workspace get a clear message instead of a pub error.

0.9.1 23 Oct 2026

Long shot: a header that sticks to the top of a list (a date strip, a pinned app bar) appears once, not on every screen over the rows; lists with rows of very different heights are captured to their real end; a page hidden under another page is never picked, in Whole screen or when tapping a part. Each picture is placed where the list really is.
A recorded clip plays on the report screen: Play clip, and Pause clip to see the screenshot again. The preview after recording says "Tap to watch" and opens the report; tray tiles mark clips with "Clip".
The tray's search sits directly above the Reported list.
First-launch notice "You're testing this app": the filmstrip and the step log keep nothing until the tester taps OK; Not now keeps nothing in the background (screenshots, long shots and clips still work); a tray switch "Remember my last 30 seconds" changes the answer at any time. New option `askBeforeRecording`: on by default in release and profile builds.
The report screen shows "What will be sent": the pictures, note, steps, errors, phone and app facts, and where it goes. "See the full issue" shows the exact title and text GitHub will get, with the redact rule applied; only picture links (and the speed test, when on) are added at send time. Sending and the view share one builder.
New "Timer 3 s" in the hold menu: a calm 3, 2, 1, then a normal screenshot; use the app meanwhile; tap the button to cancel.
New "Element" in the hold menu: tap a card or button to light it up, tap it again to capture just that part, cropped (the crop stays editable in mark-up; privacy blurs still apply).
The hold menu has 7 choices and always fits the screen: it slides to stay inside, uses two columns on a phone turned sideways, and wider pills at large text sizes.
A send that timed out after GitHub made the issue no longer makes a second issue on the next try: each issue carries a hidden line with its report's id, and the newest issues are checked for it first.
"Add to existing issue" cuts a very long report to fit GitHub, as a new issue does; before, it failed after the pictures were uploaded.
Drafts are saved to a temporary file and then swapped in, one save at a time per draft, so a crash while saving keeps the previous copy whole.
Clear on the mark-up screen keeps the automatic privacy blurs; one can still be selected and deleted on purpose.

0.9.0 22 Oct 2026

The coding agent can ask the tester a question on an issue: a comment that starts with `Question for the tester:`, with choices at the end separated by " / " (for example `Were you signed in? Yes / No`). The tray shows a button per choice and a box for the tester's own words, and posts the answer to the issue.
"Fixed in build N, try it": when the agent writes `Fixed in build N` and the app is build N or newer, a card asks "#12 is fixed in this build. Try it?". Try it starts the retest; Later hides it for that issue. Checked when the tray loads and once after app start, with GitHub delivery only: at most 2 list calls and 10 comment reads.
Time travel on the report screen: a slider through the last seconds' pictures shows how long before the report each was taken, the screen, and what the tester tapped just before. The issue lists each picture the same way, in a code block.
Fixed: with a `redact` rule set, the filmstrip was left out of the issue.
AGENT.md tells the coding agent how to ask the tester a question and how to write "Fixed in build N".

0.8.0 22 Oct 2026

New `appState` option: a few facts the app knows at the moment of a capture, for example signed in or not, or what is in the cart. They go into the report as "What the app knew when the picture was taken", with the app's `redact` rule applied, and show as a chip on the report screen. If the app's code for it fails, the capture still works and the report says why the facts are missing.
Every report carries a scenario in plain words: Given the screen where the steps start, When the taps and screens in order, Then the tester's note, and what the app knew at that moment. It is in the issue for the agent to turn into a regression test, and in the report's details for the tester.
The repro test replays every tap since the app started (up to 30), not only the last few, so it walks the tester's whole path. It ends with a check that the replay reached what the tester marked, for example `expect(find.textContaining('Due at 25:00'), findsWidgets)`, and starts with the scenario. When older taps were dropped, it says so.
Every report says the phone's condition when the picture was taken: network (Wi-Fi, mobile data, offline, VPN, Low Data Mode), the phone's speed estimate on Android, battery level, charger and power saving, free storage and memory, and heat. Shown as chips and in the details. No permission prompt; Android adds ACCESS_NETWORK_STATE, granted at install.
A speed test when reports are sent: about 1 MB from Cloudflare's public speed test, once per send. `speedTest: false` turns it off.
A retest says in words what changed on the screen since the bug picture, for example `"Due at 25:00" changed to "Due at 01:00" (NextDoseCard)`, on the compare screen and in the retest comment. It uses the names this phone kept when it sent the report, never anything under a blur; a retest on another phone has no word list.
Record 10 s: a new menu item. The button turns red and counts down while the tester uses the app; a tap stops early. The clip (5 pictures a second, private areas covered, touches drawn as red dots) becomes a new report, plays in the GitHub issue as an animated PNG, and goes to the share sheet as a file. `ReportDelivery.send` has a new optional `clip`.
Long shots of chat screens (lists that start at the bottom) and of right-to-left sideways lists come out the right way round; before, their pieces were joined in the wrong order.
On a screen with tabs, "Whole screen" always walks the up-and-down list, never sideways through the tabs.
Long shots are taken at 2x, like normal captures. A very long page is cut into several pictures, in order, each at most 8192 pixels long, all in one report. Before, a page longer than the phone's graphics limit came out enlarged and cut off at the right side (seen on an iPhone 15 Pro Max). A page longer than 10 screens gets its first 10 screens with no gap, and the tester is told. The small previews load a small copy.
If the app changes screen during a long shot, the "Long shot failed" message shows; a long text field no longer counts as a page to walk.

0.7.1 22 Oct 2026

Privacy: the filmstrip (the small pictures of the last 30 seconds) now covers passwords and private fields; before, the cover boxes were drawn in the wrong units and landed in a corner.
Privacy: "Add to existing issue" now applies the app's `redact` rule, puts `@names` in the note, the marks and the steps in code, and a picture that changed since a failed send (a new blur, for example) replaces the old one on the media branch instead of keeping it.
Android Back closes the hold menu, the long-shot picker, the duplicate card and the "Report this?" card before it reaches the app.
Opening the tray, the report screen or a retest closes the app's keyboard.
The bug button stays above the keyboard.
Android Back on the report screen saves the draft instead of throwing the note away; the X still cancels.
A double tap on Save or Send now saves or sends once.
Done on the mark-up screen comes back to the same screenshot, with the details and zoom as they were.
The duplicate check and "add to existing issue" give up after the same 30-second timeout as every other GitHub call.
Removed "4 versions". It only worked for apps that follow the phone's theme, text size and language; apps with their own settings got the same picture four times. Old reports with version labels still load.
`run` and `build` refuse a `-t` / `--target` option: it would replace the tester file and the build would never start bugsTweet. Change the import in `.bugstweet/tester.dart` instead.
`build` empties the copy's output folder first, so an older build of another flavor or mode cannot sit next to the new one in `build/bugstweet`.
Only real build output is left out of the copy: `build/` at the root and the platform projects' `build/`. An app's own `assets/build/` or `integration_test/build/` is copied.

0.7.0 21 Oct 2026

Long shot: a fifth choice in the hold menu. Tap the part of the screen that scrolls, or Whole screen, and bugsTweet scrolls it for you, takes a picture at each step, scrolls back, and joins them into one tall (or wide) capture. Private areas are blurred on it as usual.
Tall pictures scroll on the report screen and on the mark-up screen (one finger draws, two fingers scroll).
Crop, a new tool on the mark-up screen: drag a frame, Apply, and the picture, every mark and the sent picture are cut to it. Undo removes it.

0.6.0 21 Oct 2026

A new look, "Zomo": purple-blue glass panels over a blur of the app, round pills, white text, one lavender-to-pink accent, on every screen.
Poppins is the reporter's typeface, bundled and now actually applied (the earlier font never reached the text).
Motion: the hold menu's pills grow out of the button one after another with a soft overshoot; the mark-up tool pill slides with the same feel.
The mark-up screen: the picture over the blurred app, a floating hint pill and a floating tool panel.
Popup cards on the tray (Recap, the agent's answer) are solid cards.
Fixed: the Recap's Close and Share buttons overlapped the card.

0.5.2 20 Oct 2026

The hold menu: four navy glass pills spring out of the button one after another, lined up with the button, the Tray pill next to it.
The marking screen: the tool panel is navy glass, and a white pill slides to the tool you tap with a small spring. Labels stay readable while it moves.
The same on Android and iPhone; no special graphics are needed.

0.5.1 20 Oct 2026

Glass is back. The navy panels are see-through with a blur, so the app shows softly behind them, with faint bands and a bright top edge.
The hold menu's list sits in a frosted glass card.
The tray: three large frosted tiles (Recap, 4 versions, Hide) across the lower edge of the navy header, see-through cards and bottom bar.
The report screen: the note and the detail chips sit in a frosted "What's wrong?" panel on the navy; Save and Send now in a light bar.
Pill buttons shorten long labels with an ellipsis instead of running over (long labels, large text sizes).

0.5.0 19 Oct 2026

New look, "Navy": deep navy headers with lighter diagonal bands, white cards on a cool gray page, navy buttons and one amber accent, in the bundled Plus Jakarta Sans font (SIL Open Font License; works offline).
The round button is navy with a bug icon, an amber count and an amber hold ring.
The hold menu is a navy panel with one white list: Tray, Report now, 4 versions and Hide, each with a line that says what it does. It replaces the fan.
The tray has a navy header with Recap, Hide and the search, soft white cards with colored status pills, and a white bar with the Send button. It still closes by dragging down or tapping the app above it.
The report screen shows the screenshot in a white frame on a navy header, with Bug / Design / Idea pills and an amber Tap to mark up pill. The marking screen has a navy top bar.
Report rows fit a 360 dp phone: the status pill takes only what it needs and the title gets the rest.

0.4.1 19 Oct 2026

The tray's Reported list loads 20 reports at a time, newest first, and loads the next 20 when it is scrolled to its end. The tray opens just as fast however many reports there are, and every report can be reached (before, only the newest 50 showed).
A search box above the list finds a report by words in its title or by its number. When nothing loaded matches, older reports load until one matches or the oldest is reached.
Done reports stay in the list, since a coding agent may mark a report Done before the tester has checked it.

0.4.0 19 Oct 2026

Breaking change: renamed from `bugs_tweet` to `bugstweet_reporter`, and apps no longer list it. Apps add the new `bugstweet` tool under dev_dependencies; `dart run bugstweet build` adds this package to a copy of the app, for tester builds only. Store builds contain no part of bugsTweet on Android or iPhone: no code, no phone parts, no screen-capture permission, no motion permission text.
The tester start file moves to `.bugstweet/tester.dart` and imports `package:bugstweet_reporter/bugstweet_reporter.dart`. The widget map is written into the copy before each tester build, so `dart run bugs_tweet:widget_map` is gone.
Moving from 0.3: remove `bugs_tweet` from pubspec.yaml and run `flutter pub add --dev bugstweet`; move `lib/main_tester.dart` to `.bugstweet/tester.dart` (use `package:` imports for the app's files, the new import above, and `import 'widget_map.g.dart';`); delete `lib/bugs_tweet_widget_map.g.dart`; remove the `NSMotionUsageDescription` lines from `ios/Runner/Info.plist`; run `pod install` in `ios/`; build testers with `dart run bugstweet build` and take them from `build/bugstweet/`.
First version of the bugstweet tool. Apps list it under dev_dependencies (`flutter pub add --dev bugstweet`) and run `dart run bugstweet init`, `run`, `build apk|appbundle|ipa|ios` and `clean`.
Tester builds are made in a copy of the app, and bugstweet_reporter (the part testers see) is added to that copy only. This tool has no phone parts and the app never imports it, so store builds contain no part of bugsTweet on Android or iPhone.
`dart run bugstweet run` picks a phone, emulator or simulator by itself and never offers desktop or web targets. With none open, it says how to open one.
The changes of the reporter itself are in bugstweet_reporter's changelog.

0.3.5

Pinch to zoom the picture on the report screen (up to 5x), to read it while writing the note. Pinch back to see all of it. A tap still opens the marking screen; at normal size a swipe still moves to the next screenshot.

0.3.4

The hold choices are a fan again (testers preferred it to the column), read from the bottom up: Tray, Report now, 4 versions, Hide. Each label sits on the outer side of its bubble, so the two long labels never touch.

0.3.3

Behavior change: every report in the tray's Reported list offers Retest, whatever its status (Open, In progress, Pending, Done). Before, only Pending and recently Done ones did. Share delivery still has no retest.
Retest shows the way: the card at the top shows the old screenshot (tap it to see it large), the screen name and the last steps before the report, read from the issue. It folds to one line while the tester moves through the app; Capture works folded too. Android Back closes the large picture.
Copy for agents: "Copy all" and "Select" in the Reported list copy several reports at once, as one message that asks a coding agent to fix them one at a time and agree Actual, Expected and Fix first.
Fix: a screen opened with go_router's `push` (for example a report screen) was named by the address below it, so most reports said `/home`. The top page's own location is read now; the first screen is noted right after start.
The tray closes by dragging it down (or a flick); the close button is gone. A bin icon on the right of each waiting report replaces "Remove".
Behavior change: the hold choices sit in a straight column from the button out: Tray, Report now, 4 versions, Hide.

0.3.2

Fix: the retest card says what to do ("go to the screen of the bug, then tap Capture") and has its own Capture button. Before, it said "tap the button" without saying which one.

0.3.1

Behavior change: text fields are no longer blurred by default (`autoBlurTextFields` is now false). What a field shows is often the bug; the tester blurs by hand. Password fields and `BugsTweetPrivate` stay blurred, and typed text still never goes into the steps.
Fix: the stamp list scrolls when the stamps need more rows, so every stamp can be picked.
Fix: tool names in the marking dock fit their tiles with a large phone text size.

0.3.0

Every bug comes with a failing test: the issue carries a draft `testWidgets` that replays the tester's taps. Optional `BugsTweetConfig.reproTestApp` and `reproTestImport` fill in the app line.
Exact file and line in tester builds: `dart run bugs_tweet:widget_map` writes where each widget class is written; pass it as `BugsTweetConfig.widgetMap` and steps and marks name `lib/x.dart:12`.
Retest: Pending and recently Done items in the tray offer "Retest". The next capture is compared with the original screenshot on a slider; "Fixed" closes the issue, "Still broken" reopens it with a note.
Fix: a tap on a ring bubble is no longer logged as "Tapped the screen".
Four versions in one tap: a new ring choice captures the screen in light, dark, large text and Arabic right to left, as one report. Behavior change: the ring has 4 bubbles and "Report now" comes first.
Designer kit: Ruler (points, or the gap between two elements), Color (hex) and Contrast (WCAG ratio with AA pass or fail) marks.
Report from a normal phone screenshot: a "Report this?" card on iOS and Android 14+ (`BugsTweetConfig.screenshotToReport`). Behavior change: the package now has native iOS and Android parts; apps rebuild and run `pod install`. The plugin adds the `DETECT_SCREEN_CAPTURE` permission.
With a widget map, only the app's own classes name elements; Flutter's overscroll effects are no longer named.
Answer the agent in the app: a Pending issue with Actual, Expected and Fix from the agent shows a card in the tray; Go or Not quite posts the answer as a comment and removes the Pending label.
Session recap: a Recap card in the tray with today's counts around a progress ring; Share sends it as a picture (counts, app name, date only).
Optional relay: `relay/` is a Cloudflare Worker template that keeps the GitHub key out of the app; `GitHubDelivery.relay(url:, sendCode:, ...)` points the app at it. The direct key setup is unchanged.

0.2.0

Glass look: the tray is a frosted sheet over the app; the editor shows a large picture with a row of summary chips that open the details; marking happens over a floating frosted tool dock.
Instant preview after a tap (tap it to mark up). Behavior change: holding the button opens a ring of choices (Tray, Report now, Hide).
Shake to report, and shake brings a hidden button back (new dependency sensors_plus; iOS apps add NSMotionUsageDescription).
Snap to element with shape tools; stamps; numbered steps with words.
Private by default: automatic blur of text fields and `BugsTweetPrivate` areas, also in the filmstrip; `BugsTweetConfig.redact`; query strings are dropped from screen names; nothing under a blur is ever named; collected app text goes into code blocks and never pings a GitHub user.
Filmstrip of the last 30 seconds, phone settings, and a duplicate guard that offers to add a report to a matching open issue.
Smaller pictures: 8-bit PNG on the phone, JPEG when sent (new dependency image). Behavior change: uploads are `.jpg`.
Reliability: Android Back closes the reporter's layers; 30-second timeouts; a report is locked while it sends; retries on branch collisions; the issue body is cut to GitHub's limit; app error handlers are re-wrapped after the app starts; steps name only visible widgets; Cupertino buttons are recognized; a merge holds at most 10 screenshots. Behavior change: sent reports keep no pictures on the phone.
Dependency floors: share_plus >=12.0.1, device_info_plus >=11.2.0.

0.1.8

Security: the README now says to send reports to a reports-only repository, because anyone with the tester app can read the key inside it. New `GitHubDelivery.codeRepo` names the code repository at the top of every issue, so agents fix in the right place.
iPhone: reports keep their pictures after an app update. Reports now store only the picture's file name; reports saved with a full path by older versions are repaired when read, and Remove deletes the real file.
A send that failed halfway can be retried: a picture already uploaded by an earlier attempt counts as done instead of blocking every retry.
Privacy: a magnifier enlarges blurs too, so it never shows what a blur hides, whatever the order of the marks. With the Magnify tool, a tap on a marked spot places a magnifier there (it used to select the mark instead).
A clear message when the reports repository is empty ("Add a README"), instead of a raw GitHub error.
AGENT.md: reading issues from a reports repository, and a screenshot download that also works over 1 MB.

0.1.7

Blur is a real blur now. Before, it showed a gray box on phones, because the renderer's blur filter does not work everywhere. Now the picture is shrunk step by step until text cannot be read and stretched back up, which looks the same on every phone. A test checks that the blurred area comes from the picture and hides it.
Marks can be moved and reshaped. A new mark is selected right away; drag a white dot to reshape it (turn an arrow, stretch a box), drag the mark to move it. The new Move tool selects any mark with a tap. Delete removes the selected mark; picking a color recolors it.
Steps can carry words: placing a step asks for optional words, shown next to the number and in the issue (`Step 1 "tap this first"`).
Marks start where the finger touches down (they started a few pixels later). The picture no longer shrinks when a mark is selected.
Each issue has an "Open screenshot in GitHub" link per picture. In a private repo the inline picture shows only on the github.com website; the GitHub app opens the link and shows the picture.
KeepAlive, IndexedSemantics and OverlayPortal no longer appear as app widget names.

0.1.6

Voice notes now use the keyboard's own dictation key. The built-in mic button, the `voiceNotes` option and the `speech_to_text` dependency are removed, so bugsTweet never handles audio and needs no microphone or speech permission. The note box says how to dictate.

0.1.5

Hold the button to open the tray. A tap anywhere on the button saves the screen; the number is only a counter again.
Merge: in the tray, "Select to merge" joins several screenshots of one problem into one report and one issue, with all pictures, notes, steps and errors.
Marks on each screenshot: arrow, line, box, circle, pen, highlight, spotlight, magnify, blur, text, numbered steps and Identify, in six colors, with undo and clear. Marks are drawn into the picture that is sent.
Code-aware marks: at capture time the labeled elements on screen are recorded, so each mark is described in the issue by what it points at, for example `Arrow points at "Due at 25:00" (TodayScreen > NextDoseCard)`. A blur never names what it hides. The editor shows these sentences.
Voice notes (`voiceNotes: true`): speech becomes text in the note as the tester talks; no audio is kept. The app must add the microphone lines first (see `BugsTweetConfig.voiceNotes`).
`ReportDelivery.send` takes `pngs` (one per screenshot) instead of `png`.
New dependency: `speech_to_text`.

0.1.4

Issues are labeled `from-bugsTweet` instead of `from-device`.
Sending starts nothing else. The `agentMention` option is removed: the tester hands each issue to a coding agent when they choose.
The tray lists the reported issues with a status: Open, In progress, Pending (waiting for the tester), Done (closed). Tap one to open it in the GitHub app; copy its link to paste into a Claude session.
The steps at the end of each issue ask the agent to agree on Actual, Expected and the fix with the tester before changing code, to keep the status labels current, and to say what is done and what is not.
New dependency: `url_launcher`.

0.1.3

The number on the button now opens the tray. Before, the tray had no way in from the app. The touch zone is a small circle around the number, so a normal tap on the icon still captures.
Send now and Send all show "Sending with GitHub..." until the issue exists, then the issue number for 5 seconds with a light haptic. Before, the screen showed nothing during the upload and the result flashed for 2 seconds, so it looked like nothing happened.
A failed send says the report is still in the tray.
"Saved to tray" now adds "Tap the number to open it."

0.1.2

The fix prompt and the issue's first line now ask the agent to investigate and reply with the cause and a proposed change, and to wait for the tester to answer "go" before changing any code. AGENT.md updated to match.
Example app: macOS target added so a release build can be tested on a Mac.

0.1.1

Fix: capture failed in release builds (TestFlight) with `LateInitializationError: Local 'result'`, because `debugNeedsPaint` was read outside debug mode.

0.1.0

First version: floating button (tap to save, hold for a report), tray that survives restarts, automatic context (screen, steps, device, errors), fix prompt from a template, GitHub Issues delivery with a media branch, share sheet backup.
`GitHubDelivery(agentMention: '@claude')`: mention an agent on the first line of each issue so a GitHub workflow can start it automatically.