What shipped, and when.

Tank's operating instructions now document the session-watch pattern: after dispatching one or more sessions, Tank arms a persistent 20-second poll of state.json and only speaks up when something actually changes — a session finishing, timing out, or needing attention. Previously this only happened when a session happened to rediscover the trick on its own; now it's standard practice, so leaving Tank unattended while it dispatches work reliably surfaces completions and follow-ups without you having to come back and ask.

Tank could only add a scheduled task by hand-editing schedules.json, which the app reads once at launch — a schedule created this way sat dark until you quit and reopened. Tank now has three actions for this in the same actions-inbox it already uses for everything else: adding, updating, and deleting scheduled tasks. A schedule Tank creates arms immediately and shows up in the sidebar within seconds — no restart. A one-time schedule whose fire time has already passed is now rejected with a clear error instead of being silently added and never firing.

Scheduled runs can propose three kinds of work — a GitHub issue, a session worth dispatching, or a plain note — but the Suggested queue only ever showed the issues; session and note proposals were silently dropped, even though the run's own summary still reported the full count. Now all three land in Suggested: issue and session proposals get a yes/no (confirming a session starts it immediately), and note proposals are a simple read-and-dismiss. A scheduled run's summary also reports what actually reached the queue, e.g. "3 proposals (2 suggested, 1 note)" instead of a bare count. And a launch-time sweep rescues any past run whose proposals never made it into the queue, so a missed intake doesn't lose that run's ideas for good.

Issues sometimes mention a file an agent has to go hunting for, and hunting is the most expensive way to learn a repo's shape — a handful of turns of ls and find before any of the actual work starts.

The project header now has a Tree chip that generates a tree-style listing of the repo straight from GitHub. Nothing is cloned, and there is no node_modules to exclude by hand: it only ever lists what git actually tracks, so anything gitignored is already absent. Once generated, every session of that project gets it baked in at .lazytasks/tree.md and the brief points the agent at it, so a path is a lookup rather than a search.

The chip also knows when it's out of date. It checks the tree it stored against the repo's current commit each time you open the project, and turns warm yellow once the branch has moved on — so refreshing it is a click when it's needed, not a guess. If the check can't reach GitHub it leaves the chip alone rather than crying stale.

A session that committed something chunky — fonts, a video, a folder of screenshots — could fail to ship, because git only buffers 1MB of a push over HTTPS by default. Ship it now pushes with room for the whole thing.

Worse, that failure used to be reported as a success: the session note quoted git's parting words, "Everything up-to-date", which reads exactly like a retry that worked on a branch that was never on GitHub at all. Ship it now checks GitHub for the branch before claiming anything, and says plainly when the push didn't land — the workspace is kept, and the Ship button on an Unfinished session retries it.

A shipped PR used to show the brief that was sent to the agent, verbatim — what was asked for, not what came back. Any caveat, discovery, or thing the agent deliberately skipped only ever showed up if you read the diff. Sessions now write a short summary before they stop, and Ship it appends it to the PR body under "What actually happened," ahead of the Closes #N line.

My Issues used to be one flat list — fine at a handful of items, useless once it grows, because a single busy project could bury the two or three issues on a smaller one you were about to forget. It now groups by project, biggest backlog first, each section collapsible with its count always showing so folding one away never hides how much is in it. Issues sort oldest-first by default (the things quietly rotting surface at the top), with newest and recently-updated as alternatives, and you can filter down to specific projects or labels.

The console now uses a full-height sidebar, like Finder and Mail: the divider between the rail and the stage runs from the very top edge of the window to the bottom, instead of stopping below an undivided title strip. The window title has gone with it — "IndieGent" was already right there in the sidebar header, so the titlebar was saying it twice.

The projects list in the sidebar no longer sits behind a permanently visible scrollbar. Console scroll surfaces now genuinely use macOS overlay scrollers — the knob appears while you scroll and fades out afterwards — instead of falling back to the always-on kind, which is what any Mac with a mouse plugged in was getting. The list also gets back the few points of width the old permanent gutter was taking.

An empty Suggested queue is the ordinary state — scheduled runs propose at most three ideas each and dismissals are permanent — so the row was mostly a label with a blank badge, plus a band of empty space above PROJECTS. It now appears the moment a suggestion arrives and steps aside when the queue is clear. If you are looking at the Suggested screen, the row stays put until you leave it.

Settings has a Launch at login switch — off unless you turn it on. With it on, IndieGent opens when you log in, so scheduled runs fire and sessions are watched without you starting it first.

The switch reads the Mac rather than remembering its own answer, so it always agrees with System Settings › General › Login Items: change it there and the switch follows the moment you come back to IndieGent. If macOS is holding the login item pending your approval, the card says so and takes you straight to that pane.

Settings has a new Session permissions choice. A full-auto session can now launch into Claude Code's Auto Mode — a classifier reviews every action, waves through the safe ones and asks you about anything destructive — instead of skipping permission checks entirely.

It starts on Skip all permissions, which is exactly what sessions have always done, so nothing changes until you pick the other one. Sessions already running keep the mode they started with.

Background runs are the deliberate exception: they always skip every prompt, whichever option you choose. There is no terminal for Auto Mode to ask in, so a background run would sit on the question until it timed out.

Drafting a project summary from its README now re-reads the README at the moment you click, instead of trusting what the app decided earlier in the session. If three projects had no README when IndieGent last looked — and then your sessions merged one into each — "Draft them all" used to do nothing at all until you restarted the app. It now drafts them.

If a repo genuinely has no README, it says so and names the branch it checked ("No README found on pb-cutover"), rather than leaving you clicking a button that seems dead. And when a session ships work to a project, IndieGent stops believing that project has no README — sessions are how READMEs usually turn up.

Nothing moved on your Mac. Your projects, sessions, schedules, Tank's memory, your licence and every permission you've granted all carry over: under the hood the bundle identifier and the Application Support folder deliberately keep their old names, so this update is a rename you read rather than something you redo.

Everywhere a name shows up — the Dock, the menu bar, the About and Quit items, the window title, onboarding, Settings and the session briefs your agents read — now says IndieGent.

The Dock, Cmd-Tab and the About window show the IndieGent mark: near-black on the brand's accent yellow, drawn to Apple's icon grid so it sits right alongside everything else in your Dock and still reads at the smallest sizes. The menu bar carries the mark too, monochrome like every other status icon, with a small pip when a session needs you. Inside the app, the old broadcast badge is gone — onboarding opens on the full IndieGent lockup, and the sidebar and welcome-back screen use the mark itself.

The rebrand reaches the pixels. The app is white where the page is, warm beige where the surfaces are — cards, panels and the project sidebar — with near-black text and one accent, IndieGent yellow, spent only on the thing you're meant to click: the Start session button, the live-session dots, the pill that says an agent is running.

It reads in IndieGent's own type, too. Plus Jakarta Sans carries the headings and Inter carries everything else; both ship inside the app, so they look the same on every Mac whether or not you have them installed. Branch names, timers and paths stay monospaced, where they belong.

And the app finally follows your Mac's appearance. Switch to Dark Mode and IndieGent goes with you — every colour has a dark counterpart rather than the app pinning itself to light.

The rebrand now follows the app past its own window. The pull requests your sessions open are signed by IndieGent, background operator runs introduce themselves as IndieGent, the licence email you get after buying says IndieGent, and the download itself arrives as IndieGent-2.6.0.dmg — the first build where nothing you receive still says Lazy Tasks.

IndieGent has always been where you send work out. It's now also where you find out about it coming in. A new Inbox at the top of the sidebar shows what happened on your projects — an issue assigned to you, someone @mentioning you, a review someone's waiting on — with an unread count on the bell so you can see it without going looking.

Each row says what happened, where, and (where GitHub tells us) who did it. Click it to open the thread on GitHub; for issues, there's a Start session button right there, so going from "someone assigned me this" to an agent working on it is one click. New events show up within a couple of minutes.

It stays short on purpose. Only the three things that name you personally appear by default, anything you did yourself never counts, and your first run arrives calm rather than with a backlog of unread. If you do want everything a repo gets up to — new issues, replies on threads you follow — right-click it in the sidebar and turn on "Watch all activity".

The number beside a project used to be every open issue in the repo, which made a collaborator's workload look like yours. It now counts what you can actually pick up: issues assigned to you, plus issues nobody has claimed. Anything already assigned to a teammate sits beside it as a plain, unboxed number, so you can still see it's there without it reading as a todo. A project whose issues all belong to other people no longer shows a badge at all. Home's summary line and Tank both follow the same rule — Tank's snapshot now carries the actionable count alongside the total, so it recommends work that's genuinely yours.

A project's one-line summary came straight from its GitHub description, and most repos don't have one — so most projects said nothing about themselves, including in the snapshot your agents triage from.

You can now write that line yourself: hover the summary under a project's name and edit it. And you usually won't have to write it — IndieGent reads the repo's README and drafts a one-liner for you, which you take with a click, tweak first if you like, or ignore. Repos you add from now on offer their draft as they arrive; the ones already sitting blank are gathered on Home under "projects with no summary", where "Draft them all" does the lot. Accept one and it's yours; "Use it & set on GitHub" writes it as the repo's description too — only ever when you ask, never from a background run. Descriptions written on GitHub now reach the app on their own as well.

The chart on the home screen looked good and said nothing: a bar was a height, and there was no way to find out what it was a height of.

Now run the cursor along it. Each day lights up as you reach it and tells you what happened — how many sessions, how many issues you picked up, how many PRs shipped, how long agents were actually working, and which repos. A quiet day answers too, with the date and "Nothing that day", instead of being a gap you can't click on. It works the same on the weekly grid once your garden outgrows the daily bars. The card also shares its exact left and right edges with the Field Notes rows below it at every window size, so Home no longer reads ragged.

Confirming a suggestion used to leave the done card sitting in the queue, so a tab whose whole point is "things waiting on you" slowly filled with things that weren't. The confirmation is now a moment rather than a resident: the card turns yellow, ticks, and tells you the issue number it was filed as — with an Open button straight to it on GitHub — then slides out of the list a few seconds later.

And clearing the queue lands you somewhere designed instead of on a bare line of text: "All clear", a quiet dial that pulses while something is armed to look, and the facts you'd otherwise go hunting for — when the next run fires ("Nightly review runs tonight 9pm"), when suggestions last arrived, and a Run now button if you don't feel like waiting for tonight. A failed run says so in orange instead of letting a broken night look like a quiet one.

A project's open issues arrived in whatever order GitHub handed them over — newest first, which meant the backlog you'd been carrying longest sat at the bottom. They're now sorted by issue number, lowest at the top: your oldest open work first, the freshest ideas last, the same way every time. An issue you file while the list is on screen still appears immediately at the top, then settles into its place once GitHub gives it a number.

Put Tank on a schedule. The new SCHEDULED section in the sidebar holds standing orders — "Mon–Fri 9pm: review closed issues and suggest tasks" — that run headlessly in the background, no terminal window. Create one from the + button with a proper editor: prompt, time picker, day-of-week chips, an optional single-project focus, and a one-time variant. Each entry shows its next run in plain words ("tonight 9pm", "Mon 9am"), how the last run went, and a spinner while it works. Runs came due while the app was closed or the Mac asleep? You get one catch-up ask on launch — "was due yesterday 9pm — run now?" — never a silent skip, and never a double-run. Scheduled runs report rather than act: each deposits structured proposals for your review instead of changing your repos behind your back.

A new Suggested section in the sidebar collects draft GitHub issues proposed by scheduled runs (capped at 3 per run). Each card leads with the title, target project, and a one-line "why"; the full body expands in place, and you can touch up the title or body before filing. Confirm creates the issue on GitHub in one click; Dismiss buries the idea permanently — it's remembered, never suggested again, and future runs are told what you said no to. Nothing reaches GitHub until you confirm.

The built-in nightly review makes the two features one story: Mon–Fri at 9pm, Tank reviews every issue that closed across your projects since its last successful run — a catch-up after a weekend away covers the whole gap — and proposes up to 3 follow-up issues into Suggested, each with a one-line "why now" tied to the specific issue or PR that prompted it. Nothing meaningful closed? It proposes nothing — an empty night is a valid result. Suggestion cards show which run proposed them ("Nightly review · Jul 31, 9pm").

Selecting a project could shave the left edge off the sidebar ("PROJECTS" became "ROJECTS"): the project view's deploy row could demand more width than the window had, overflowing the layout and pushing the sidebar partly off-screen. The deploy row now wraps its buttons onto a second line when the window is narrow, and the main content area is structurally capped so it can never displace the sidebar again.

Enlarging the window now makes the home view expand to fill the full width instead of holding a fixed-width column with dead space on the right. Sidebar project rows (and group headers) now truncate long names to one line, so selecting a project can no longer make its row render wider than the sidebar — the cause behind the sidebar squish some users saw after resizing.

The README now documents the model-selection feature: setting a project's default model via the model chip, and overriding it for a single dispatch from an issue row's "Start session with model" menu.

Headless dispatches could silently run the wrong claude: if an old copy sat on the non-interactive shell PATH (e.g. a year-old homebrew install), it shadowed the current one your version manager (nvm/fnm/asdf) puts on the interactive PATH — and every dispatch died with "exit 1". Tool resolution now probes the interactive shell first — the same environment your terminal sessions run in — so the CLI your terminal uses is the one headless runs use too.

When a tool fails printing its error to stdout (as claude -p does), the session note used to read as a bare exit code. It now includes the tool's actual error text, so you can see what went wrong without digging.

The model picker menus (project default and per-dispatch) now suggest all current claude CLI aliases — fable, opus, sonnet, haiku, opusplan, opus[1m], sonnet[1m] — instead of just opus/sonnet/haiku. The field is still free text, so any model name the CLI accepts continues to work.

Each project can now set a default model: click the model chip next to the profile chip on the project page and pick a suggestion or type any model name the CLI accepts. Any single dispatch can override it from an issue row's "Start session with model" menu, and Tank can do the same by adding "model" to a start_session action. Nothing set means the provider default, exactly as before — and cheap tasks no longer have to burn an expensive model.

Shipping is no longer a single click. The first click on any Ship control — the "Ship it" pill or the paperplane buttons — arms it: it turns amber and reads "Ship?". A second click within 3 seconds ships; clicking anywhere else or waiting disarms it. No more accidental ships from a stray click.

Headless dispatches failed instantly with "env: node: No such file or directory" when node was installed only through a version manager (nvm, fnm, asdf, …). Those tools set up their PATH in interactive shell config (.zshrc), which the runner's non-interactive probe never read. Tool and PATH resolution now probes your shell the same way a terminal window would (with the old behavior as fallback), so headless runs see exactly the PATH your terminal has.

A new Running entry sits next to Home and My issues (⌘3 — projects moved to ⌘4–⌘9). It shows every agent session across all your projects on one board, grouped by project with the sessions that need you sorted to the top. Ship, reopen, discard, or dismiss straight from there — it's the same session the project's own tab shows, so everything stays in step. Project headers jump to that project's tab.

Issue rows — in a project's OPEN ISSUES list and the My-issues queue — now carry a small moon button next to Start session. It starts the same session headless: no terminal window, and because the issue is linked, the finished PR's "Closes #N" shuts the issue when it merges. Previously that combination was only reachable through multi-session dispatch. Same Pro gating and first-run explainer as the deploy panel's Run in background button.

Background sessions now actually run on every Mac: the agent used to inherit the app's bare environment and could die instantly with "env: node: No such file or directory" — it now gets the same PATH your terminal has. A wrap-up that can't count the session's commits (say the project's default branch was renamed) no longer assumes "no changes" and deletes the workspace — it keeps everything and says why. Runs that end without shipping — failed, stopped, or nothing to push — now release their GitHub issue claim so the issue doesn't look taken, a push whose PR creation fails keeps the workspace so the retry still links "Closes #N", and no-op runs stay out of the ledger stats.

Headless agents also grew a leash: sessions can be stopped (workspace kept), a run that exceeds 45 minutes is stopped automatically, discarding or shipping a running session first makes sure the agent process is dead, and quitting the app no longer leaves orphaned agents working in the dark.

Four bits of housekeeping around headless runs. Tank's state.json now marks each session as headless or not and lists sessions wedged with unpushed work in a separate needsAttention array, so Tank stops nagging about healthy background runs and knows which ones actually need you. Every session leaves its internal status file behind when it's dismissed, discarded, or swept at launch — previously unfinished and failed sessions leaked one forever. Branch names now stamp down to the second, so two same-titled tasks dispatched together can't collide. And asking Tank for a background run on the free tier now starts a normal terminal session and says so, instead of quietly ignoring the license.

Starting several sessions of one project at once — terminal or headless — used to fail part of the batch with "git fetch failed" or worktree errors: every session raced the others for the project's shared repo cache, and git's lock files made the losers error out instead of wait. Sessions of the same project now take turns for the git plumbing (clone, fetch, worktree add/remove), so a 5-session dispatch starts 5 sessions. Two issues with near-identical titles started in the same minute also no longer collide on the same branch name, and a finished headless run now ships its work even when the session status changed while Claude was wrapping up its last response.

Shipping several sessions in quick succession could leave already-closed issues sitting in a project's OPEN ISSUES list and the My-issues queue until a manual refresh. Three races conspired: a slow issue re-fetch could overwrite a newer list and resurrect an issue closed mid-fetch, a refresh requested while another was in flight was silently dropped, and GitHub itself reports a just-closed issue as open for a few seconds. Refreshes now queue a trailing re-run instead of being dropped, stale fetches can no longer overwrite fresher ones, and issues closed by a ship are tombstoned so a laggy fetch can't bring them back.

The toolchain check screen no longer greets returning users on every launch. If everything passed last time, LazyTasks shows a brief branded "Welcome back" splash while it re-checks your tools in the background, then fades straight into the console. The checklist only reappears if something actually broke — and when it does, it greets you by name and points at the one thing that needs fixing. The checklist itself got a redesign: per-tool status icons, copyable fix commands, and a live progress count.

Keyboard shortcuts are now discoverable everywhere they act. Buttons wear little key-cap badges (Start session ⌘↩, Run in background ⇧⌘↩, Create issue ⌘↩, esc to cancel), and a full cheat sheet lives under Help › Keyboard Shortcuts — or just press ⌘/. The same list appears in Settings, along with a one-click jump to System Settings › Keyboard › App Shortcuts, where every menu-bar shortcut can be rebound to whatever keys you prefer.

The Settings gear was a tiny icon squeezed into the PROJECTS header, where it looked like it configured projects. It's now a proper labelled row at the foot of the sidebar — the usual Mac spot — wearing a ⌘, keycap. That shortcut is also documented in the ⌘/ cheat sheet.

Adding a secret could look like it did nothing: the sheet opened without keyboard focus (keystrokes went nowhere), pressing Return never submitted, and the Add button gave zero feedback when a field was still empty. The Secrets sheet now puts the cursor in the KEY field on open, Return walks from key to value and submits, an incomplete add says exactly what's missing, and every successful save confirms with "KEY saved on this Mac." Disabled pill buttons across the app now visibly look disabled instead of just ignoring clicks.

A new Multi session button above the open issues list turns the rows into checkboxes — select the issues you want worked in parallel, hit Start N sessions, and one agent session deploys per issue, each linked to its issue so wrap-up PRs close the right one. Sessions open terminal windows by default, same as single dispatch; a toggle in the selection bar switches bulk runs to the background instead (Pro), for when many selections shouldn't mean many windows. Esc or Cancel leaves selection mode without starting anything.

When multiple sessions shipped in sequence, only the first PR merged — each branch's release-notes entry made the next PR conflict, and the ship gave up without telling you. Ship now catches the session branch up with the main branch first (release-notes entries merge automatically), and when a merge genuinely can't happen, the session lands as Needs merge with the reason, instead of a green "Done" hiding an open PR.

Sessions can now adopt a working profile — a skills.md-style brief that shapes how the agent works, not what it works on. Five built-ins ship with the app (Senior Engineer, Frontend UX/UI Wizard, Test Engineer, Docs Writer, Security Auditor), every one editable in the new profile studio: a two-pane editor with live autosave, an Edited badge the moment a built-in diverges from stock (one click reverts), and room to write your own from scratch.

Set a project default from the new Profile chip in the project header, or pin a different profile to a single issue via Start session with profile in the issue row's menu — "this bug wants the Test Engineer" is one click. Session rows show which profile each agent adopted, and profiles reach terminal and background sessions alike through the session brief.

Profiles are plain markdown files in Application Support › LazyTasks › v2 › Profiles — copy them between Macs or share them with your team.

The console now drives from the keyboard. ⌘↩ submits the new-issue composer (from anywhere in the sheet, even mid-typing in the description), Esc cancels it, and the title field is focused the moment it opens. The deploy panel gets the same treatment: ⌘↩ (or plain Return in the title field) starts the session, ⇧⌘↩ runs it in the background.

Everything lives in a real menu bar, so the shortcuts are discoverable — and rebindable in System Settings › Keyboard › App Shortcuts: File has New Issue (⌘N), New Session (⇧⌘N), and Add Projects (⇧⌘P); a new Go menu jumps to Home (⌘1), My Issues (⌘2), the Ledger (⌘L), your first seven projects (⌘3–⌘9), the project filter (⌘F), and Tank (⌘T); View › Refresh Issues (⌘R) re-syncs with GitHub on demand. Small touches round it out: Esc closes the repo picker (its filter is auto-focused), Return confirms group-name prompts, and tooltips mention their shortcuts.

The Secrets, Cloudflare, and Fresh/Cached controls no longer crowd the project title as shouty uppercase labels. They now sit as small capsule chips on the repo · branch line — a tiny icon plus a short value. Anything still at its default renders as a faint outline chip, so the header only carries as much weight as the project actually uses; missing secret values still show the amber n/m count.

The home-page Garden no longer greets new users with a barren 24-week grid. While your history spans four weeks or less, it shows a compact daily bar chart of your sessions since day one; after that it becomes the familiar weekly heatmap, widening its window as your history grows until it reaches the full 24 weeks.

Cached-mode projects used to run every session in the same shared checkout, so two sessions at once could trample each other — one session's wrap-up could sweep up another's uncommitted work, commit WIP onto local main, or a new session starting could switch the checkout out from under a running one. Each session now gets its own git worktree (private files, index, and branch) created from the base branch at start and removed after wrap-up, while the cached clone still provides fast opens. As a belt-and-braces check, wrap-up also refuses to commit unless the workspace is on the session's own branch.

Starting a session from an open issue used to leave the row unchanged — the "Start session" link was still sitting there as if nothing had happened. The row now swaps it for a live status chip ("Session running", "Needs input", "Wrapping up") while a session for that issue is in flight, in both the project's Open Issues list and My Issues.

The home screen's stat row now has a fourth card: Agent Time, the total wall-clock time agents have spent working across your wrapped-up sessions (shown in minutes until it crosses the hour mark). It fills the empty space next to Issues Handled, PRs Shipped, and Day Streak.

The New Session panel in a project can now be collapsed down to just its header — click the header to toggle. Handy if you mostly file issues and start sessions from the issue rows: collapsing the panel keeps your open issues front and center. The choice sticks across projects and restarts.

The My Issues list and its sidebar badge refresh the moment anything changes your queue — creating an issue (yours or Tank's), assigning or unassigning yourself, starting or discarding a session on an issue, or a session shipping and closing its issue. The app also re-checks in the background every couple of minutes and whenever you switch back to it, so issues filed on GitHub itself show up without a relaunch.

Projects can now hold secret variables — API keys, admin credentials, anything the repo's gitignored .env would contain — so agents in fresh workspaces can actually run the app they're working on. A SECRETS badge in the project header opens the editor: add keys one at a time or import a whole .env from the clipboard. Every session gets the values exported into its environment and written to an untracked .env at the workspace root. Values are write-only and strictly per-machine: never shown again, never synced, never in a command or log. Key names follow the project through settings sync, so a second Mac shows exactly which values still need entering.

Assign a Cloudflare account to a project (header menu CF · <name>, managed in Settings → Cloudflare accounts) and every session on that repo runs wrangler as that account automatically. Profiles live in ~/.cf-profiles, the same convention as the cf shell switcher, so existing profiles just appear. Tokens never leave the machine; concurrent sessions can target different accounts.

The new-issue composer now defaults "Assign to" to you instead of Nobody, and issues can be edited from LazyTasks — "Edit issue" opens the composer pre-filled and saves straight back to GitHub. The description and "Brief the agent" fields are now real multi-line editors that grow with what you write.

The home stats are now a small dashboard: issues handled, PRs shipped, and your current day streak. Below them, "The Garden" — a contribution heatmap of your last 24 weeks of sessions — and "Field Notes" with fun facts from your ledger: top repo this week, pace versus last week, all-time power day, early bird or night owl.

"Ship it" now closes the session's terminal window once the workspace ships, and when a full-auto session merges itself, its issue vanishes from the Open Issues list immediately.

Creating, editing, labeling, assigning, and closing issues all apply on the spot — no spinner while GitHub catches up. GitHub stays the source of truth: every change reconciles against a re-fetch, and if one didn't take, the list snaps back with an error banner. A failed create reopens the composer with everything you typed intact.