What shipped, and when.

The Dock icon, menu bar mark, sidebar tile, lockup, and onboarding screens all draw the hub now, in place of the old bars icon. The menu bar version is redrawn thicker so it stays legible at that size, and the notification pip now sits in the mark's own open corner instead of overlapping it.

Crossing off a finished session (or hitting "Clear finished") used to drop it out of the "N finished today" count along with the row — so clearing your board could read "nothing finished today" right after a busy morning. The count now comes from a permanent completion log that dismissal never touches; the visible list still clears exactly as before.

A new close_pr action closes a pull request straight from the inbox — never merges it, can leave a comment in the same step, and reports a clean already-closed/merged result instead of an error if you're too late. It can also delete the PR's branch afterward, but only a branch IndieGent created, and never one a session still has checked out.

The price moved from $19 to $99 — still one payment, still no subscription, still two machines and major versions included. Settings → License now shows the real figure on the buy button.

Agents is where you dispatch from now. A new READY band in the Agents panel lists open issues you can pick, stage, and dispatch without leaving the app.

Every row — including the ones needing your attention — now archives directly with e, ⌫, a hover icon, or a right-click, no more Approve → Apply round trip. A 5-second Undo toast (or ⌘Z) follows, and checking several rows lets you archive them all as one batch. The needs-your-attention row's "Draft reply" is now a smaller, deliberate action behind a one-line confirmation, rather than the easiest thing to misclick.

A new inbox sweep from the same schedule now retires its own earlier still-pending card instead of piling up alongside it — an afternoon sweep replaces the morning one for the same project. Approving an actionable card now shows what actually happened ("Archived 5 messages") once the dispatched session finishes, rather than a generic "1 session running" that either lingered or vanished before the real outcome was known. And a headless run that changes no code but did something real — pontius apply archiving mail, with nothing for git to show — now completes visibly: its own summary becomes the note instead of a misleading "nothing to push", and it shows up in Tank's watch with a durable copy of that summary.

The Agents panel has a fourth band, READY: the open issues you or nobody owns, five at a time with a door into Projects for the rest. Pick one and it lands on the Agents stage above whatever is running — the issue's own body as an editable brief, a model, headless / terminal / read-only, a timeout, and one Dispatch. Nothing is sent to GitHub and nothing starts until you press it; the brief you edit goes to the agent, never back to the issue. ↑↓ move through the list, ↵ stages, ⌘↵ dispatches with the options as shown and esc clears. The header's yellow "+ Dispatch" button, which only ever opened a chat window, is now an outlined Ask Tank that hands Tank the staged issue already typed — for the ask the options row can't express.

A completed session's card now shows the pull request number right next to the issue it closed — #66 → PR 70 — instead of just the issue number, so a completion can be matched to the GitHub PR at a glance instead of guessing which of two nearby numbers is which. Sessions with no PR (read-only runs, killed sessions, ones closed by hand) render exactly as before.

Running the unit suite used to launch 8-9 full copies of the app — one per parallel test worker — each grabbing a Dock icon and stealing focus. Those clones now run as accessory apps: invisible in the Dock, never activated, same parallel speed. The everyday app is untouched.

On a Mac set to a Thai region, scheduled-run directories and Email search result dates were coming out stamped with the Buddhist year (2569) instead of the Gregorian one (2026), because the date formatters that name them read the Mac's region settings unpinned. They now always render Gregorian years regardless of the Mac's calendar/locale settings.

Three keys changed, and only three: ⌘1 Projects · ⌘2 Agents (used to be Home) · ⌘3 Scheduled · ⌘4 Email · Home is now the mark itself, or ⇧⌘H · ⌥⌘3 "Running" is gone — Running is ⌘2 now. ⌘[ / ⌘] still step across the four rail modes.

Your running agents now have a tile of their own. ⌘2 is Agents — the robot in the rail — and it opens a panel listing what's wedged, what's in flight and what shipped today, over a board that puts the same three counts under a big "Agents" heading. Clicking a row in the panel selects that session on the board and scrolls it into view. There's a Dispatch button in the panel header that opens Tank.

Home didn't go anywhere: the IndieGent mark at the top of the rail is now the Home button, and its key is ⇧⌘H (⌘H stays macOS's Hide). The house tile is gone. Home is the morning page now — today's date and open counts, your GitHub inbox, the ledger's field notes, and what recently shipped — with nothing in flight in it.

⌘1 Projects, ⌘3 Scheduled, ⌘4 Email, ⌥⌘2 My issues, ⌘0 and ⌘[ / ⌘] all work exactly as before — ⌘[ / ⌘] step the four rail tiles, and Home is reached from the mark rather than by stepping. If you quit with Agents open, that's where you come back to.

Without Pontius, the Email tile and the Clerk console used to disappear entirely — now they're always there, just locked, with a tooltip that says why. Click either one (or press ⌘4 / ⇧⌘T) and you'll land on a page that explains what Clerk does, shows what its console looks like, and offers Get Pontius → or I already have Pontius — which re-checks right there and unlocks both tiles in place if it finds one, no restart needed. If it's still not sorted, it names the specific reason: not installed, installed but not signed in, or signed in without an active licence. Settings › Inbox shows the same short pitch in place of the empty pane. If you're already licensed and signed in, nothing changes.

Settings → Clerk → "Lookup tool" replaces the old "Lookup hub" field: a command template ({query} is substituted), a label, and a list of env vars to pass through — empty by default, so a fresh install's read-only investigations work from the repo alone until you configure one. A "Use riku-company-analytics" preset button fills the fields for Stuart's own setup; if you already had the old Riku hub key set, it's carried forward automatically on first launch — nothing to redo.

A read-only investigation's posted findings comment now redacts email addresses before it ships — [email protected] becomes j***@example.com, domain kept — wherever one shows up in the comment, including inside a code span or a mailto: link. The local findings file Clerk drafts from is unaffected; only what leaves the machine is scrubbed.

Two things to switch it on: mint a key on the analytics dashboard's new Keys page (scope read:*) and paste it into Settings › Clerk › Lookup hub; and know that the heartbeat driving all of this now defaults to 60 minutes and is a setting in that same screen (15/30/60/120), not the hardcoded 15 it used to be.

Once a read-only session answers a question, Clerk writes the reply first, checks you haven't already handled it by hand, then asks — one line, the draft attached, f for the findings behind it. Nothing sends without your explicit yes, for every reply an investigation produces, no exceptions: money anywhere in the thread is never promised or refunded without you saying so first. Say yes and the filed issue closes if the answer was the whole point of it, or stays open with a comment if the investigation turned up something worth fixing.

When a mail needs facts the inbox doesn't have, Clerk files an issue, dispatches a read-only session against it, and waits — one investigation at a time, tracked in its own investigations.json. A 20-minute watch (capped at 45) reports back the moment findings land, or tells you plainly if the session came back empty or timed out. A second question from the same correspondent while one's already running just gets folded into it — never a second session.

The mechanism behind an investigation is a session the app itself keeps on a short leash, not just a persona told to "look, don't touch": it runs headless, defaults to sonnet, sees a fixed look-don't-touch brief and only RIKU_API_KEY/RIKU_API_URL instead of the project's whole .env, and ends at a findings write-up — Question / Answer / Evidence / Confidence / Couldn't see — posted as a comment on the linked issue. A read-only session never pushes a branch or opens a PR, full stop. One that commits anyway is treated as a defect: it lands on Needs Attention with its workspace kept, rather than being read as an answer.

Those two allowlisted secrets no longer need pasting into every project's own .env either — set them once, app-wide, in Settings › Clerk › Lookup hub (#323), and a project's own secret still overrides it if one's already there.

When an email is genuine feedback or a bug report, Clerk can now file a GitHub issue straight from the mailbox — picks the project (asking if it's between two), checks the repo's real labels, dedupes against open issues, and reports back with a receipt: "Filed owner/repo #45 from Jamie: ...". Wrong call? One word closes the same issue. It never sends anything to the person who wrote in.

Clerk's inbox watch used to re-check every fifteen minutes, hardcoded. It's now an hour by default, and configurable (15/30/60/120 minutes) in Settings › Clerk (the Inbox/Pontius card). Changing it takes effect the next time Clerk starts.

The left edge has been rebuilt. A 48pt column of icons runs down the side of the window — Projects, Home, Scheduled, Email, with Tank, Clerk and Settings at the foot — and beside it one 240pt panel shows whichever of those you're looking at. The old rail stacked all of it in a single scroll, so with twenty repos the project list started halfway down a column you had to scroll; now the list you use every minute is the whole panel, and the counts for everything else sit on the icons where you can see them without leaving it.

Home collects what's stuck, what's running and what shipped today. Scheduled puts your standing jobs above what they've suggested. Email lists the last sweep in the order it wants reading — the ones only you can answer first, then the drafts waiting on a yes, then a single line for the filing.

The keyboard shortcuts moved. ⌘1–⌘4 now pick a sidebar mode, ⌘[ and ⌘] walk between them, ⌘0 collapses the panel to just the icons, and ⌘J jumps to any project (it used to be ⌘4–⌘9, and only reached the first six). My issues and Running kept their numbers, now with ⌥ — ⌥⌘2 and ⌥⌘3. If you had ⌘2 or ⌘3 memorized for something else, they now open Home and Scheduled instead. All of these are still rebindable in System Settings, and ⌘/ lists the lot.

The panel is draggable between 200 and 320pt and remembers its width, its mode and whether you collapsed it. The window minimum moves from 900×560 to 1040×680 to fit the new edge and still leave the stage room to work.

A second console beside Tank, for mail instead of code. Clerk opens a terminal that already knows both mailboxes: it triages with Pontius every fifteen minutes, files the noise itself with a one-line receipt you can undo for an hour, and brings you the rest one line at a time — who, what they want, what it would do, ok? Answer "ok", "no — <correction>", "later", "ignore", "ignore always" or "you decide", and it writes what it learns into your Pontius knowledge base so the same question never comes back twice.

It writes to customers in the same voice the sweep drafts in, so what Clerk sends and what you approve in the Email module read like one person. Open it from the Clerk button in the Email module, the rail below Chat with Tank, or Go › Chat with Clerk (⇧⌘T) — all three appear only on a Mac with Pontius installed.

Opening a message no longer needs a wider window. At IndieGent's default size the reader now takes the whole Email pane, with ‹ Back to sweep (or Esc) to return and the ✓ ✎ ✕ kept in that bar so you can still approve straight from a message you've just read. Widen past about 1100pt of pane and the list comes back beside it, as before — the message you had open stays open either way.

"Run sweep" used to be the deterministic engine and nothing else, so the reply rows came back with empty drafts and rule names where the reason should be. A sweep is two stages now. Triage still lands the board in seconds, with the housekeeping already ticked — then one background session reads each message that needs an answer, greps the knowledge base for who the sender is and what was said last time, and writes a ready-to-send draft plus a one-sentence reason a human would recognise. Rows waiting on it say "Drafting…" and stay fully live: approve, skip and Apply never wait, and if the drafting run falls over you keep the sweep.

Needs-you rows get the same treatment. They stay needs-you — nothing an agent writes can move a row out of that pile — but they arrive with a real reason, and often a draft you can just approve.

The scheduled sweeps use the same words: put {{drafting-rules}} in a scheduled task's prompt and it expands to exactly what the Run sweep button sends, so the 8am sweep and the button can't drift apart.

Settings › Email also grows three model pickers — drafting, apply, and where "Open in Tank" / "Draft reply with Tank" go. Those two used to drop into the Tank chat, which runs on the top tier whether the email needs it or not; they now open a normal watchable session on the pontius project on whatever model you pick (sonnet by default), with "Use Tank chat" still there if you preferred it. The model is named on each button's tooltip.

Click any message in the sweep and it opens beside the list — the real thing, formatted the way the sender wrote it, with images and links and tables intact. Copy out of it and the links and line breaks come with you. Plain-text mail reads as plain text. Attachments are listed under the header.

Remote images stay blocked until you press Load remote images, so opening a newsletter doesn't tell whoever sent it that you did. Scripts never run. Links open in your browser rather than inside the app.

File › Print (⌘P) prints the message you're reading, properly — not a picture of the window.

There's a search box in the header. Type, press return, and it searches your whole mail — not just the inbox — with optional From and date filters. Results replace the list and open in the same reader; clearing the box puts your sweep straight back, exactly as you left it.

Two ways to answer. Draft reply with Tank opens a session with the whole message already in the brief. Reply… is a small plain-text box for the ones that are faster to type than to explain — and replying no longer files the message away behind your back.

A scheduled run's proposal can now carry the actions that carry it out. Its card in Suggested reads Approve / Edit / Dismiss: Approve runs the actions through Tank's own pipeline — start a session, file an issue, close one — and the card answers with what happened ("Approved → 2 sessions running"). Edit opens the plan itself in a monospaced sheet first, for the fields the run marked editable, so you can change the call before you make it.

A run can hand the dispatched session a payload — a triage plan, a list of issues, whatever it worked out — and the session reads it as part of its brief instead of re-deriving it. Actionable proposals also get a larger allowance per run than text ones (six instead of three), because approving one costs a click rather than an afternoon.

Proposals that are just text are unchanged: same buttons, same cap, same behaviour.

If Pontius is installed and licensed on this Mac, the sidebar grows an Email row: the last Pontius sweep, as a short list of yeses rather than a mailbox. A chip row says what it found — how many need you, how many drafts, how many templates, how much housekeeping — and the rows below are grouped the way you'd clear them: the ones only you can answer first, then the replies waiting on a yes, then the filing.

Housekeeping arrives already approved; replies wait for you. Each reply's draft opens in a monospaced sheet if you want to change a line before it goes. Apply turns everything you approved into one background session that runs pontius apply — dry run first, then for real — and reports what happened to each message.

When a sweep turns up something new that needs a human, macOS tells you, with a sound.

On a Mac without Pontius none of this exists: no row, no Settings switch, nothing to turn off. If you have it and would rather not see it, Settings › Show Inbox (Pontius) hides the row without stopping anything.

Dispatching a session on haiku — from Tank's inbox or the app's model menu — used to fail the moment it started, because the claude CLI only resolves the fable, opus and sonnet aliases itself and passed a bare haiku straight through to the API, which rejected it. The app now maps haiku to the current Haiku model id before handing it over, so the model the menu offers is the model you get. Every other model name is still forwarded exactly as typed, so a model released tomorrow keeps working today.

A background session that is refused at launch like this also no longer leaves a dead workspace behind: when the run fails within seconds and the workspace holds nothing at all, the failure is recorded on the session and the workspace is cleaned up, instead of parking a "workspace kept" row with nothing to salvage. Anything a session actually committed or changed is kept exactly as before.

Every session used to be told to record durable learnings straight into the repo's CLAUDE.md, and nothing ever trimmed it — some repos' CLAUDE.md had grown past 500,000 characters, most of it re-sent to every agent on every turn. Sessions are now told to keep CLAUDE.md a short, capped map (~12,000 characters) and route durable learnings to docs/notes/<topic>.md instead. If a session grows a workspace's CLAUDE.md past the cap anyway, its PR now opens with a one-line heads-up so it's easy to catch and fix in review.

Clicking into a project or My Issues could beachball IndieGent into "Application Not Responding" — the OS hang reports show the main thread pinned at 100% inside SwiftUI layout while sessions were in flight. Several things fed that: a project's header read the file-tree cache, the secrets file, the profile directories and the whole session ledger from disk on every redraw; every session status save republished the session list to the UI even when nothing had changed, and so did the periodic badge/toolchain refreshes; and My Issues was built from nested lazy stacks, the exact layout the hang reports were stuck in. The header now reads its facts once, off the main thread; unchanged data no longer redraws anything; My Issues uses plain stacks; overlapping issue loads coalesce into one; a failed refresh keeps the list you already had instead of blanking it; and every gh call the console makes now gives up after 60s, so a wedged gh can never hold a screen's loading state open.

A dropped actions-inbox.json that Tank wrote non-atomically, or genuinely malformed JSON, used to be read the instant the file-system watch fired — often before the write had actually finished — and a bad first read declared the file permanently malformed with nothing re-arming the watcher until the app restarted. The watcher now gives a write a short settle window (a few retries a beat apart) before giving up, and a parse failure — settled or genuine — always reports the error and stays ready for whatever Tank writes next. Tank's own instructions now also ask it to write the inbox atomically (temp file + mv).

A background session whose agent armed a monitor and ended its turn expecting to be woken used to be treated as finished — the agent exiting is the only completion signal a background session has — so the session shipped a PR that was really just the brief, with nothing actually verified. Two changes: every background session is now told up front that monitors and waits don't survive the end of a turn (wait in the foreground or don't wait at all), and a session whose agent never wrote its summary is flagged as half-done rather than listed as a normal success — a warn-toned "Done — verify" on the board, an "ended without a summary" warning in the PR body, and the same flag passed to the operator so it re-checks before telling you the work shipped.

When the app dies while a session is still working, the finished-but-unshipped work in that session's workspace is offered back as a salvage card. That card only ever appeared in Suggested — a browsing area you have to go and look at — so after a crash you could know a card should be there and still not find it. Salvage now lights up the same "needs you" signals a session waiting on input already earns: the menu bar icon's dot and the badge next to IndieGent in the sidebar, both visible without knowing where to look, whether or not the crashed session's own row survived the restart. In Suggested itself a salvage card no longer looks like every other "maybe file this issue" suggestion — the row, its badge and the card's border all turn warn-toned, so the one card that's about your own unsaved work reads as urgent.

Clicking Ship it while a session was waiting on live background processes — a leaked headless browser, a forgotten dev server — used to tear the workspace down without touching them, leaving the survivors running with nowhere left to live. The automatic path already cleaned up at its five-minute deadline; shipping by hand now runs the same sweep before teardown, recorded in the session's history exactly like the automatic one. The click still means the workspace goes down right away — there's no added wait, just a tidy-up on the way out.

A background session whose agent left something running — a headless browser, a dev server it forgot to stop — used to sit on the board looking busy until someone killed that process by hand; one session waited forty minutes for a browser nobody was using. Two separate causes, both fixed: a session now waits at most five minutes past the agent's own exit before tidying the leftovers up and shipping, and a leftover process that happened to inherit the agent's output no longer stops the session finishing at all. While it's waiting, the row says so plainly ("Waiting on 2") with the countdown in its tooltip, rather than reading like ordinary work in progress, and anything it had to clean up is named in the session's history. Work the agent is genuinely still doing is unaffected — the wait is there precisely so a long-running job isn't cut off — and stopping a session yourself keeps its workspace and leaves its processes alone, exactly as before.

If IndieGent is killed — a crash, a force quit, a power cut — after an agent has finished and committed but before its work is shipped, that work used to sit in a kept workspace with nothing on screen saying it existed. IndieGent now scans its own workspaces on launch and puts a card in Suggested for each one holding unshipped commits or uncommitted changes, with a brief that already names the workspace, the branch, and the original task. Each stranded workspace is only ever offered once.

Salvaging a stranded workspace (above) copied its work onto a fresh branch but left the original directory sitting on disk forever, since nothing was ever responsible for removing it. IndieGent now deletes a salvaged workspace once every byte of it is verifiably safe elsewhere: nothing uncommitted, its branch pushed to the exact commit on disk, and that branch's PR confirmed merged. This runs automatically once per launch, and a "Clean up" button on the salvage card lets you do it by hand as soon as the PR lands. Nothing holding unpushed work is ever deleted automatically.

Signing into Grok Build after IndieGent had already started used to go unnoticed until the app restarted — Tank kept routing work away from Grok because its one-time toolchain check never ran again. IndieGent now rechecks Grok's sign-in status continuously while running, so a sign-in from a separate terminal is picked up within a few seconds instead of requiring a relaunch.

Dispatching a session with a different provider than a project's usual one — for example running Grok Build on a project whose saved default model is a Claude name — used to forward that name straight through and crash the CLI on an unrecognized model id. IndieGent now recognizes which provider a saved default model actually belongs to and drops it when the dispatch is using a different provider, so the target CLI starts with its own sensible default instead of a name it doesn't understand.

When a full-auto session ships and its PR merges, IndieGent now deletes the lazy/* branch behind it — so your GitHub branch list stops accumulating dead branches every time a task ships. A launch-time sweep also goes back through each project's existing branches and removes any whose PR has already merged or closed, cleaning up the backlog that built up before this shipped. Branches from sessions you're still reviewing (PR left open) are never touched.

A headless session whose agent kicks off a long-running background command — a release build, notarization, a test sweep — used to be at risk of being torn down the moment the agent itself went quiet, even while that background work was still running. Wrap-up now checks for live processes still working in the session's workspace and waits for them before tearing anything down, showing "Waiting on a background process" on the session row in the meantime. The wait is bounded by the session's existing timeout, so a forgotten dev server can't hold a session open forever.

The "Session running" chip on issue rows carried a perpetual pulse animation, and every frame of it re-laid the entire window for as long as any issue-bound session was in flight. With a few concurrent sessions on screen that loop could saturate the main thread until the app beachballed — sessions kept working in the background, but the console was unusable until relaunch. The chip's dot is now static, matching every other "live" indicator in the console, and the continuous re-layout is gone. The Suggested tab's empty-state dial, the last other spot in the app with an unattended pulsing animation, got the same fix.

Follow-up to the fix above: even with that bug gone, the machinery that processes Tank's action inbox, reads session status updates, and wraps up finished sessions all ran on the app's main thread — so anything that tied up the UI also silently froze the background work. That machinery now runs off the main thread entirely, so a busy console can no longer stall a dispatch, lose a wrap-up, or leave a Tank action sitting unprocessed.

Tank's shipped instructions now tell it to pick a model — and, when it's the better fit, the Grok provider — for each session it dispatches, instead of leaning on a project's default: cheap models for deploys, verification, docs, and other mechanical work; the top-tier model reserved for genuinely hard dev; Grok for copywriting, bulk edits, and planning drafts. Tank also checks whether Grok is actually installed and signed in on your machine before recommending it. This ships in every fresh install's Tank instructions, not just as one operator's memory.

Every project now has an Agent chip in its header, next to Profile and Model — pick Claude Code or Grok Build, and every session that project starts runs the CLI you chose. Interactive and headless (background) sessions both work, and Tank's start_session action accepts its own "provider" field for dispatching an individual run on whichever CLI fits the job, regardless of the project's default. Unattended-approval flags are always applied — a Grok session never sits on a permission prompt nobody's there to answer.

Onboarding shows Grok as its own row, separate from the required checklist: installing it is entirely optional, and nothing about existing Claude-only setups changes.

Grok Build's CLI discovers a repo's CLAUDE.md on its own — the same project instructions a Claude session already follows — so a Grok session now works from the same brief. Workspaces dressed for Grok no longer receive the Claude-specific hooks file they never ran anyway.

One thing Grok still can't do: report live progress while it works, so a Grok session's status only moves when you ship it or a headless run finishes.

The session-watch pattern Tank arms after dispatching work (added last release, #198) used to speak up twice for the same session: once when it completed, and again later when that entry rotated out of the state file — you dismissing it, or it simply aging off. Tank's watch now emits one line per genuinely new event instead of re-announcing whenever the summary changes, so a completed session is reported once, with no repeat pings for something you already saw.

A background session's watchdog — the ceiling before a still-running headless run is stopped and left on Unfinished with its workspace kept — is now 59 minutes, up from 45. And Tank can now ask for a different ceiling per session: its start_session action takes an optional "timeoutMinutes": N (10-120), for a job it expects to run long. Omit it and a session gets the new 59-minute default; an out-of-range value is rejected with a clear error rather than silently capped.

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.