TempCode 1.0.200

• The installed app's TypeScript language server ran as Electron-as-node and died: vtsls.js was spawned as process.execPath with ELECTRON_RUN_AS_NODE=1, which only works while the runAsNode fuse is on (dev); the packaged build turns that fuse off on purpose (a leaked ELECTRON_RUN_AS_NODE must not break the app), so the child booted a second TempCode, the single-instance lock killed it, and lsp.sta
• temp-code is ready to distribute: the repo is public at github.com/LandonDev/temp-code (every blob in the history was scanned for tokens, keys, OAuth blobs and Keychain dumps first and came up clean; .gitignore now covers .temp-code/, artifacts/, src/main/server/media/ and release/), the Mac build is signed and notarized (electron-builder.yml: hardened runtime, the Developer ID Application ident
• The gh listing paths are gone: the renderer's per-project list fetch and its 30-second memory cache (fetchInboxItems, listInboxItems, peekLastInboxList and the rest of the list cache, githubRepo, listGithubWorkItems, formatGithubQuery, the rail-project helpers and collectInboxResults in githubTasks.ts), the git_github_repo and git_github_work_items commands in native.ts, and the server's githubW
• Inbox filters and rows group by workspace: the filter menu (rows built by the pure inboxFilterMenuRows in src/renderer/src/lib/inboxFilterMenu.ts, so a test reads them) gains a Mine section on the GitHub tab, Authored by me / Assigned to me / Review requested as any-of checkboxes computed against the snapshot's viewer, stored as mine: { authored, assigned, reviewRequested } (an older assignedToM
• The inbox opens from the stored snapshot and the rail dot is right at launch: a new renderer store (src/renderer/src/lib/inboxStore.ts, connected in main.tsx beside workspaceStore) reads github.inbox once when the socket opens (SQLite on the server, never GitHub) and holds the only path to the network, refreshGithub, which InboxView alone calls: on open when the stored snapshot is older than a m
• The inbox fetches every GitHub workspace in one GraphQL pass and keeps the snapshot in SQLite: 24 repos, 60 points, 6,543 ms, 6 requests, one gh spawn (bun run script:e2e-github-inbox against the real ~/IdeaProjects checkouts). GithubInbox (src/main/server/githubInbox.ts) reads the token once through gh auth token (ghAuthToken / forgetGhToken in github.ts, cached per process, dropped on a 401
• Workspaces know their GitHub repo: every git workspace row carries owner/name read from its origin remote in .git/config (gitRemote.ts: a worktree's .git file is followed through gitdir and commondir to the shared config; github.com over https, git@ and ssh:// map to a slug, any other host is null) with no process spawn, stored on new nullable workspaces columns github_repo and github_repo_check
• The rail's "Working" panel and the workspace shimmer stop counting threads that finished long ago: archiving a live thread (the planning thread a new implementation thread auto-archives in create()) now settles its row idle. interrupt() only asked the handle to stop and left the closing idle to its stream, and dropHandle() disposed that handle right after — a disposed claude handle stays mute,
• Research boards show evidence, and chats know a research job when they see one: a cite_source app tool (src/shared/research.ts; in-process for claude sessions inside a research tree only, over the stdio bridge for codex, app.citeSource on the WS) records the page or file an explorer read and the one-line claim it supports; a url the agent already fetched or read through curl gets the claim on it
• Research threads keep what their explorers find: every subagent spawned inside a research thread gets an app-assigned findings file beside the root's report (/.temp-code/reports//-.md, carried in its planPath, named as findingsFile in the spawn result and list_agents) with a fixed contract appended to its brief — write it early with frontmatter, evidence for every c
• Agents show HTML pages inline in threads (T3 Code's html_preview / html_render, ported): a Claude or Codex thread can build one self-contained page (chart, table, diagram, collage, mockup), check it with html_preview — a PNG screenshot, contentHeight and the page's console output with page.html:N locations, rendered in a hidden offscreen BrowserWindow on its own partition that only reaches pub
• The error banner's Continue can restart every stopped thread on another model: a chevron beside Continue / Continue all opens "Continue as" with the model picker and effort control, and Continue there switches each errored thread in the tree (errored subagents too) before its continue turn. The same provider keeps the conversation; another provider gets the transcript handoff a composer switch u
• A thread no longer sits on "Watching" behind a background task the model has forgotten: once a task is ten minutes old and a whole turn went by without the model touching it, the driver asks the model in one short hidden turn ("Checking background tasks" in the transcript) to stop what it no longer needs with TaskStop or say it is still waiting; a stopped task retires at once and the thread sett
• Threads no longer stay on "Watching" after the model says it is done: the driver now settles on the CLI's own in-flight task list, not a task level that can go stale. drivers/claude.ts trusted system/background_tasks_changed alone for the live set; in a CosmicPrisons thread the CLI stopped sending that level mid-session while fifteen more tasks started and reported, so two ids from the last leve
• A planning thread that wrote its plan and then ended its turn on a background wait reads "Plan ready" again, not "Watching". Since v184 a thread whose turn ends with a live Monitor, cron or run_in_background Bash settles as watching instead of idle; usePlanReady only peeked the plan file of idle planning threads, and TabIndicator rendered the watching branch before the planReady one, so such a
• A zen turn no longer shows the same line twice, once dimmed as a thought and once in white as the paragraph. Some harnesses mirror a reasoning summary as the very next assistant message word for word; groupTurnItems (transcriptActivity.ts, repeatsNextProse) now drops a reasoning block whose whitespace-normalised text equals the next non-empty assistant block, so only the white paragraph renders.
• Zen transcripts read like the Claude app: the model's prose never folds. Every assistant paragraph renders full size where it streamed, interleaved with the work, and each run of tool calls between two paragraphs (or before the first, or after the last) folds into one dimmed row titled by the calls themselves ("Read 3 files · Searched for tokens", "Ran the tests (1 failed)"), present tense whil
• An account refresh pass no longer holds the loop ~2.2 s every snapshot. After v189, each snapshot still re-picked 224 idle Claude threads between two accounts with near-equal headroom, and every moved row bumped the sessions version, so notifyMeta rebuilt the whole 3,190-row session index once per row. expectAccountsUnder (refreshAccounts and scope-pin changes) now holds the pass's meta pushes i
• The app no longer freezes for ~16 s at a time (beachball, window unresponsive) since v185. Every accounts snapshot change (the gateway nudges one on each observed response) runs refreshAccounts over every open thread, and each thread's routeFor asked registry.liveLoad, which read the whole sessions table: 1,778 threads x 3,190 rows per pass, back to back while threads stream, all on the main loo
• Streamed events cost less main-thread time: SQLite commits at synchronous=NORMAL, the threads index reads 4 KB per mirror instead of whole files, and every known synchronous section reports itself to stalls.log when it runs long.
• The server no longer re-reads and re-indexes every session row on each meta push: the session index is cached per sessions-table version.
• The sidebar, title bar, rail and Archive page do less work per session push: O(1) workspace lookups, a title bar that ignores streamed frames, one seen-mark a second, a dock badge on meta change only, and archived threads a page at a time.
• Session pushes from a running fleet cost one re-render per frame instead of one per push, and no longer flush the event batch early.
• New Fable threads spread across accounts by 5h headroom and live thread count instead of stacking on one account until its 5h window blows; the Fable window now moves on every response and a Fable-window 429 is charged to Fable, not Weekly; sign-outs from two refreshers racing on one token stop; every logged 429 names its account and model. Bumps aliax-core to d71cea3 (orderByReset takes load/ca
• Stalls are now recorded: a multi-second freeze on a thread or page switch leaves a line in /logs/stalls.log saying what was in flight, how many pushes streamed, and how many threads ran.
• Threads waiting on background work now show "Watching" instead of looking done, keep their process alive until the work lands, wake visibly, and take queued subagent reports in one turn. A Claude thread that ended its turn with a run_in_background Bash, a Monitor, a CI poll or a session cron used to read as idle, get its process (and the tasks with it) killed by the 10-minute idle sweep, and str
• Codex 0.156+ sign-in through the gateway no longer fails with "workspace routing discovery failed". Bump aliax-core to 0359612: Codex now calls accounts/check before every turn (and at the end of the ChatGPT app's Codex sign-in), addressed as /api/codex/accounts/check against a base without a /backend-api marker, and splitPath used to forward that to chatgpt.com/backend-api/api/codex/accou
• Zen mode no longer hides the answer that comes before a question. groupTurnItems (transcriptActivity.ts) treated only the trailing run of prose as the answer, so when the model wrote a long reply and then asked (an AskUserQuestion is a tool block, the last visible one), the reply folded into the activity group as one truncated phase headline, and stayed folded after the user answered because the
• Chat threads stop asking whether to start a thread, what to do next, or whether a reading is right. The chat preamble (threads.ts) told the model to "ask questions liberally" and to "offer to start a planning thread", and half of the 30 structured questions chats had asked were those handoff confirmations. A chat now asks only for information it cannot get itself (a preference, a fact about the
• Continue on a thread whose row holds a display slug (fable-5.1) no longer fails with "issue with the selected model (fable-5.1[1m])". v180 fixed only the composer send; Continue and every other respawn (session.continue -> continueRun, refreshAccount -> dropHandle -> handleFor) read the model from the stored row, and two rows still held fable-5.1 verbatim because resolveModel (shared/catalog.ts)
• Follow-ups on threads opened before the model catalog loaded no longer fail with "issue with the selected model (fable-5.1[1m])". A thread hydrated at boot before the live Claude catalog lands carries the built-in picker id (claude:fable-5.1); once the catalog replaced the built-in list, nativeModelId (lib/models.ts) no longer found that id and stripped its prefix to fable-5.1, which the boot no
• Claude subagents spawn with the 1M context window by default. orchSpawnAgent (orchestration.ts) sets context1m when the target supportsContext1m and the caller did not pass context1m: false; true on a model without 1M is still refused. The +1m legend and the spawn_agent descriptions (orchestration.ts, app-mcp-bridge.mjs) say so; app_start_thread is unchanged. Tests in orchestration.test.ts.
• An account whose usage poll was throttled no longer drops behind the rest of the auto pick order. aliax-core 2df7622: orderByReset (failover.ts) demotes an account for a live report.rateLimit mark only when it has no windows on file, since that mark comes from GET /api/oauth/usage answering 429 and says nothing about the model API, while the cached windows still show the room; and a usage() swee
• Opus threads spend the accounts whose Fable window is gone and leave the fresh ones to Fable. aliax-core 6e7a1f8: a scoped pick for a model without a scoped cap leads with the least Fable room (a full, unlifted window first; absent or lifted is full room), then the soonest weekly reset, then usedPercent; Fable keeps room-required-and-soonest-reset; a lifted window (reset in the past) sorts as un
• The Claude usage summary now classifies as a limit, so failover runs on it. aliax-core f2233a7: classifyLimitText reads "Current session: 100% used · resets …" / "Current week (all models): N%" / "Current week (Fable): N%" lines, naming the window at 100% (session → 5h, week (all models) → weekly, week () → that model's window; several at 100% name the most specific), lines under
• Codex app-server boot keeps its stderr and retries a boot that dies in the handshake. AppServerConn reads stderr line by line into a bounded tail (40 lines / 4 KB, rmcp transport spam dropped) and rejects pending requests with AppServerExit, which carries the exit code and that tail, so "codex app-server handshake failed" now says why (tonight: codex's own logs_2.sqlite locked by its prune, exit
• Idle threads re-pick their account whenever it could be stale, and no code path swaps a thread's model for the default any more. SessionRegistry.refreshAccount: a thread with no live process re-picks fresh (the best account for its model now), one with a process keeps its sticky pick and is dropped when the pick moved so the next send respawns under it, mid-turn threads are left to the gateway;
• A model change re-picks the thread's account fresh, and the pick lands the moment a model is chosen. routeFor/expectAccount take { fresh } (chooseAccount with no sticky current): a thread that changes model takes the best account for the new model instead of staying wherever it was while that account still had room (the prompt cache is per model, so staying kept nothing). session.tune accepts mo
• A thread is always auto: the per-thread account pin is gone and the composer's AccountControl is a read-only indicator of the account the thread spends from (click opens the account list read-only with a check on that account; a project or workspace pin shows its pin glyph and "From project X" / "From workspace Y"). The expected account is computed ahead of the spawn (SessionRegistry.expectAccou
• docs: the Aliax section of docs/PLAN.md points at the per-scope accounts plan (scope segment, accountRouting, per-thread failover; the global pin is Aliax's)
• Bump aliax-core to 3524294: the scoped-routes probe goes to /__aliax (the service-prefixed control path the shim forwards), so a thread routed through the shim learns whether the owner reads its scope segment; the bare /__aliax never left the shim.
• Project and workspace account pins in settings: the project dialog gains an Accounts group (one select per provider: Inherit (workspace: X) or Inherit (auto), then the saved accounts) saved through project.setAccounts, and the workspace settings page an Accounts heading with one row per provider (Auto, then the accounts) saved through workspace.setAccounts. A pin set here applies to every thread
• Per-thread account UI: an AccountControl beside the model picker (composer and plan Start) shows the account the thread spends from (nickname, else the email's local part; Auto before the first spawn) and opens the account list; the list now describes a thread (where its account comes from, an Auto row that clears the thread pin, a check on the account in use, a pin on the explicit pin) and a ro
• Per-thread account routing: each thread's child spends from its own Aliax account. handleFor resolves the thread's pin (thread > project > workspace) and asks AccountsService.routeFor for the account to name (the pin with pin=1, else the sticky current account while it has room, else the best pick for the model), persists it as the row's account and hands the route to the driver; routedEndpointF
• Per-scope Aliax accounts, storage and resolution: sessions.account_pin / account_current and projects/workspaces.account_pins (JSON, one per provider) with SessionMeta.accountPin/account and ProjectMeta/WorkspaceMeta.accountPins; accountRouting.ts resolves a thread's pin (thread > project > workspace, per provider; a child never inherits its parent's thread pin) and chooses the account a spawn n
• Bump aliax-core to 4f5f8ab (gateway scoped routes): unified rate-limit headers and Codex snapshots are now attributed to the account the answer came from (onResponse.account, observeCodexSnapshot(snapshot, account)) instead of the global pin, and pickNext passes scoped for a per-thread limit so the pick ignores other live models. No user-visible change yet: drivers still send unscoped URLs.
• Chats outside a workspace are back: a fixed "Chats" entry in the rail opens the home, where the sidebar lists the loose chats (no project, no workspace) with New chat running in the home directory, the tab strip shows only those chats, and a loose thread opened from search or the inbox brings the home forward. Rail signals, last-thread landings and the strip key loose threads under "~"; with no
• Add Claude Opus 5.5 (claude-opus-5-5) to the model catalog and bump the bundled Agent SDK to 0.3.280 (CLI 2.1.280, the first build that accepts the new model). No banked resets for Claude: api/oauth/usage carries no reset-credit field, so the accounts popover has nothing to show.
• Parked session tabs no longer reconcile a transcript nobody can see
• Auto account switching picks the account whose weekly window resets soonest, not whichever 5h clock is nearest: aliax-core d2a867e orders failover candidates by weeklyLabel(serviceId) (Weekly for Claude, week for Codex) whatever window just closed, since the week is the budget that actually runs out
• Tool calls into a connector show its logo again: mcpServerOf() reads the server name out of any mcp__server__tool call, and the transcript row's icon now wears that connector's brand (Linear, Convex, GitHub, ...) for any call that isn't the app's own or a subagent spawn — a plug glyph where we have no logo, exactly as before. cosmic-admin gets its own mark (Downloads/cosmicgames-mark.png) sinc
• A usage limit that only shows up as error text fails over and continues the thread by itself: aliax-core 95fb2ef classifies Claude and Codex limit messages (5h, weekly, credits, per-model, transient); the drivers tag error events with limit.window and log unclassified limit text to logs/limit-text-misses.log; AccountsService.failover charges the pinned account's window, picks the next account wi
• The gateway fails over on a usage-limit 429 by itself: aliax-core 6add708 classifies the refusal (unified headers and Claude/Codex bodies), marks the pinned account's window full with the provider's reset, asks AccountsService.pickNext for the next account with room in every window the refused and every live model spend (soonest reset first, confirmed by a forced poll), pins it and replays the b
• Claude and Codex threads route through Aliax's shim or our own gateway: endpointFor(service) picks the shim when it answers /__shim, else the gateway, else leaves the CLI default; the claude driver sets ANTHROPIC_BASE_URL, the codex driver sets chatgpt_base_url on thread/start, listens for account/rateLimits/updated and asks account/rateLimits/read once the thread is up, feeding the pinned Codex
• The paused and errored banners span every workspace: Continue and Continue all now gather every paused or stopped-on-error thread across all projects, not just the one open, since resuming acts on a thread by id and needs no project switch first. Needs-you keeps its per-project scope
• Gateway feeds usage from traffic: every Claude answer's unified rate-limit headers move the pinned account's 5h and Weekly windows in the shared cache and push the footer without a poll; every 429 is logged with its limit headers and body to /logs/gateway-limits.jsonl for the failover classifier; aliax-core b16fdb5 (parseUnifiedHeaders, codexSnapshotToWindows, observeWindows, 429 body
• A working workspace names itself, no dot: the rail's busy-state chip — a pulsing dot that opened a popover — is gone; instead the row's own running thread (or the loudest one, +N more) sits as one indented line underneath, spinner and title, click to jump straight to it, no menu to open. Paused, needs-you and unread keep their chip and popover unchanged
• Accounts popover matches Aliax's detail: each row shows the plan, an exact percent left per usage window with its bar and on-pace tick, the refill countdown and clock time per reset group, rate-limit, expired and banked-reset lines, and the surface widens to fit up to four window columns
• Gateway: the server runs its own Aliax-compatible proxy on a loopback port and claims the shared shim marker when it may: packaged and prod-data builds always claim, a dev dir claims only with TEMP_CODE_CLAIM_SHIM=1; it takes over from Aliax or a dead owner, stands by behind another live temp-code and reclaims when that one goes, watches the marker with a 30s tick, and hands the marker back on q
• Usage footer reads Aliax's accounts: the footer shows the pinned account with a bar per usage window (percent left, on-pace tick, refill countdown, how many other accounts still have room) and its name opens a list of every saved account to switch with one click; the server builds the snapshot from Aliax's shared vault through aliax-core, follows Aliax's settings and usage cache, and falls back
• Start building carries the 1M context choice: the plan's Start popover read effort out of its model settings for reasoning but never read context, so an implementation or orchestration thread spawned from a plan always opened at 200k regardless of the toggle shown
• A settled thread always opens at the bottom: the scroll-up left behind by an earlier visit — the reader's own, or memory restored from a cold remount — only gets put back while the run is still going; once a thread is done there is nothing left to watch from up there
• Left rail: click a workspace's status chip to see each chat, not just a shimmer
• Fix appshot fly-in replaying every time you return to its thread
• Archive dormant threads by type: the workspace menu and each project card menu add one row per thread type present under the all-types row (chats, plans, implementation threads, orchestrations, research threads, with counts), sparing the focused thread's tree like the all-types row; one type alone adds no row since it would repeat the row above
• The context meter survives a relaunch: every context reading off the harness stream is written to context_tokens/context_window on the session row through its own statement (a reading is not an edit, so updated_at and the list order stay put), the row seeds liveContexts at boot and rides every meta, and the renderer lets the meta's reading win over the fold's, because the server keeps context ev
• Sending a message flies the bubble from the composer field to its resting place as a transform-only FLIP: the field's rect is recorded at submit and the new user turn measures its rest after the transcript parks it, then translates in over 420ms on cubic-bezier(0.32, 0.72, 0, 1) at full opacity with will-change only for the flight, while the composer clears on the same frame; the flight cap is m
• Claude Fable 5.1 (claude-fable-5-1) leads the built-in Claude list with the same reasoning ladder (low, medium, high, xhigh, max) and a 200k/1M context setting the live catalog offers, so the picker, modelsFor, resolveModel and spawn agree on one entry; a built-in id still resolves through its native id once the live catalog replaces the list, and a unit test pins both paths
• The paused strip is one row: a 28px warning-tinted bar at composer width with a hairline, the pause glyph, Paused, the frozen elapsed, then a ghost Stop and a filled Continue on the right; the slot stays 28px whatever the state and only opacity moves, 120ms on the ease token, so the composer never shifts
• "Archive dormant threads" spares the thread on screen: dormantThreads takes an exclude set, and the workspace menu and every project card pass the focused session's whole tree — its root and every descendant, from the same store the strip reads its active id — so the thread you are looking at never archives under you however settled it looks
• Every floating surface lifts to one plane: the overlay fill is a 15% lightness at 0.96 alpha in dark and white at 0.97 in light, drawn over a single 20px saturate(1.4) blur with the hairline, so the model picker, modals, approval toasts, the agent sheet, tooltips and menus rise together and a dense transcript never reads through them
• Glass is real again: the window is created with under-window vibrancy and a clear background when the mirrored Glass setting is on, the renderer keeps html, body, root and the shell opaque until its first paint, then the sidebar's own 0.8 tint is the only layer over the material, the 40% shell wash is gone under glass, and the setting says turning it on takes a relaunch
• Side panels open and close as one piece: the subagent panel, the orchestrator log and the project rail share a push Drawer whose shell tweens its width over 280ms out and 200ms back on the drawer curve while the body sits left-anchored at its final width inside a strictly contained clipping shell and fades over 120ms, its phase is derived at render so a close never remounts the body and a reopen
• A sent message rises out of the composer: the optimistic bubble plays a 320ms transform-and-opacity entrance from 18px below at 0.96 scale with its origin bottom right, the block carries a born stamp instead of a flag so the server echo's remount resumes the entrance mid-flight through a negative animation delay and blocks loaded later never replay it, the class and its will-change drop at anima
• The workspace kebab and each project card kebab gain "Archive N dormant threads", greyed with no count when there are none: it archives at once, no confirm, every settled, seen, unpinned root with nothing working, paused or recoverable in its tree (the strip's live rule), sparing working, needs-you, unread and pinned roots and any planning thread that holds a plan; the workspace item covers proj
• Subagent rows fold under their root unless the root or one of them is working, or the open thread is one of them: the root's tail shows a chevron and count that unfolds them, a click pins either state per root in localStorage under monocode.tc.subagentRows, a pin that matches what the work would show is dropped so a root un-pins itself by settling, there is no height tween and the section re-mea
• The left rail lists workspaces only and says so: it no longer adds the focused thread's project folder as a row of its own, so sending in a project thread no longer conjures a row that vanishes on leaving; the highlighted row is the workspace the app is in, and the rail's labels read Workspaces, Add workspace, Pin workspace and Workspace options
• Coming back to a workspace lands on the thread it was last on: the open tab holding that thread wins over the first open tab, then the most recently visited tab of the workspace, then the remembered thread opens, then a blank one; a blank draft is never remembered, so a workspace never seen lands on a new thread
• The live lines under a working project card get their hairlines back: a line above the first thread, one between each pair and one below the last (divide-y and border-y at content/10), as before the dialog pass dropped them
• The sidebar's project list and the left rail's project list start 8px below their headers (pt-2 on both scrollers), so the first card and the Pinned label no longer sit flush against the seam; Chats, Archived and the pinned block ride the same scroller and take the same inset
• Floating layers get a real fill: one --color-overlay token (base background at 88% dark, 92% light) and one .floating-surface class (overlay fill, hairline, 24px blur, 12px on the animating popover/modal/toast/picker/command variants) replace the bg-content/10 washes on Popover, Modal, ApprovalToasts, AgentDetail, FilePicker, SymbolPicker, CommandPopover and both tooltips, so a model picker or d
• Glass is back: the window takes vibrancy after the first paint while the new Settings > Appearance "Glass" toggle is on, the content pane stays opaque (main-pane glass now defaults off), reduced transparency and the toggle both go solid through a window:disable-glass IPC, and the TEMP_CODE_GLASS gate from the fork-storm days is gone
• The updater swaps the installed bundle atomically: copy beside it, two renames, then open — a swap script that dies mid rm -rf can no longer leave a half bundle macOS calls damaged
• Prod moves onto master: the IntelliJ engine spawns headless on both sites so an expired build no longer bounces a Java icon in the Dock, and CLAUDE.md drops the two-line split and the temporary no-dev-instances rule now that the user has confirmed the new shell's performance
• Close the design-system pass: AttachmentChip's remove glyph drops its dead size ternary
• Leftover audit-A values off the rail and composer: SessionReview's box washes /5 with sentence-case Undo all / Keep all and a /10 pressable Review, ContextControl's meter is h-1, commit shas in ChangesPanel and BranchPanel and the FileEditor footer sit at 11px tabular, the composer box and queued rows wash /5, GoalControl's textarea hairline is /10, ProjectDialogs takes the kit INPUT_CLASS, the
• Motion remainder on the ease bar: the thread strip's active wash no longer glides on a layoutId (a 120 ms colour swap, so ⌘1..9 and ⌘] measure no layout) and chips fade in and out over 120 ms with the reorder glide still capped at GLIDE_MAX_ROWS; ComposerAction crossfades its glyph in 100 ms without mode="wait", blur or a half-scale, and presses through .pressable; approval toasts glide up o
• Settings, empty states, title bar and tabs on the donor idiom: settingsBits gains the kit Input, a concentric Segmented and a disabled-aware Select that ThreadDefaultsDialog, OrchestrationRules, buildSettings and SettingsView adopt in place of hand-rolled inputs, with MatrixSpinner loaders, DANGER buttons, one-clause copy, 11px uppercase section labels and text-2xl page titles; TitleBar tabs are
• Dialogs, pickers and menus on the donor idiom: a shared ConfirmDialog kit (GHOST, PRIMARY, DANGER, DialogFooter, ErrorLine) replaces every window.alert and window.confirm in GitChangesPanel, the rail ChangesPanel, TitleBar group delete and NotesView delete; RemoveProjectDialog and SwitchBranchDialog sit on Modal with the kit input and an inline error line instead of an alert; SymbolPicker and Fi
• Thread views on the donor idiom: fleet rows and angle groups use MatrixSpinner and the shared StatusDot instead of a ring spinner and hand-rolled dots, 12px secondary text and size-3.5 icons throughout, with reorder glides capped at GLIDE_MAX_ROWS; the fleet panel and side panel open at full width with a 120 ms content fade instead of a width tween and take PaneHeader; AgentDetail sits on the mo
• Transcript on the donor idiom: the column owns its one px-4 gutter and every block, stamp, chip, divider and spawn row drops its own; prompts sit in a rounded-xl bubble with the turn stamp row always reserved so spacing holds without a time; tool invocations, todo lists and code blocks share the rounded-[10px] hairlined bg-content/6 card with EditRow and its corner chip; one TodoList renders in
• Left rail and sidebar footers on the sidebar idiom: h-9 section headers with uppercase labels and a size-6 add button; h-7 12px project rows washed bg-content/10 when selected, the menu space reserved and the diff stat always shown so nothing re-truncates on hover, the kebab fading in over 120 ms instead of hidden→grid; Working agents are rows under a hairlined header with a flat accent dot (n
• Right rail on the sidebar idiom: h-9 hairlined headers and one px-2 gutter across Changes, Branch, Build and Debug; h-7 rounded rows with the open review file washed bg-content/10 (App threads selectedChangePath through ProjectRail); section labels, empty states, commit box and file names on the donor sizes; hunks, commits and variables indent 8 + depth·12 and the hunk Stage control is an alway
• Global design tokens and motion bar: one transition default (120 ms on the settle curve) and an --ease-out custom property replace every easing keyword and the 0.22 bezier in index.css; a .pressable class and a global focus-visible ring; Button presses to 0.96 with no hover scale and a 400 ms ripple; StatefulButton crossfades its label in a stable footprint instead of a per-letter blur cascade;
• Arcade is an idle screen: the boards run only after 2 s with no pointer or key input anywhere in the window and stop on the next one, so a tab or project switch (a click, a key) never shares its frame with a board paint and a moving pointer keeps them still; canvases size and allocate on the first frame that draws, not on mount; a game you took control of runs on your keys
• Project-switch chrome measures nothing on the swap: a strip or sidebar whose rows change wholesale keys its presence boundary on a generation (no exit or enter springs, no layout snapshots, no shared-element glide from a chip that is gone) and glides again 400 ms later with a fresh layout id, never past 40 rows; chips take a per-row layoutDependency so unchanged re-renders skip snapshots; the si
• Tail and transcript window budgeted in rows, not turns: the server walks back about 300 transcript rows (a prompt, a tool call or one message each) over light columns and cuts on a row boundary, the store asks for rows, and the transcript mounts its last 100 rows and grows by 150 on demand, part-way through a turn if it must
• Stage marks on the open path: click, session ready, pane commit, deferred transcript commit, first rows (performance.mark under a tc: prefix) so a CDP run can read where an open spends its time instead of polling the DOM
• First-paint budget: a collapsed edit row mounts no diff lines (the body renders the first time the diff opens and stays for the close tween); the cold profile charged 1.4 s of DiffLine and highlightCode work to bodies nobody had opened
• Opening a thread paints on its last 20 turns: the click path and the boot restore of the active tab load through loadSession (tail first, the rest folds behind) instead of getSession, which waited for the whole log before the tab could open (a 38k-event thread took 17 s to appear)
• First-paint budget: a collapsed edit row no longer reads its file to number the hunks (the read waits until the diff is opened), and a history image chip fetches its bytes only once it comes within a screen of the viewport (useNearViewport, IntersectionObserver)
• Tab switch paints the strip, pane header and composer on the click; only the transcript body mounts in a deferred pass behind them (DeferredMount, keyed on the session), replacing the deferred whole-pane swap
• Tail-first transcript load: a first fetch asks session.events for the last 20 turns (the server walks back from the end, so a 40k-event log costs only the rows it returns), paints them, then fetches the rows before in the background and refolds in 2000-row slices; block ids come from seqs so the painted turns keep their keys when the head lands
• Hover prefetch: a tab or thread row hovered 150 ms fetches its transcript, and the two most recent tabs warm in an idle slice after the active one paints (two fetches in flight at most, none while the socket is down)
• Transcript scroll engine reads layout once per frame, before the runway spacer write, so a collapsing runway no longer forces a second layout every frame
• Blank tabs collapse on restore: one empty thread tab per project (the active one, else the newest), and the arcade runs only in the focused pane of the shown tab, a frame after it paints
• Block render cache: a remounted settled block is a lookup, not a parse
• Parked panes schedule no frames: every timer and animation loop inside a pane gates on a PaneVisibility context, not document.hidden
• Parked tabs unmount: only the active tab and the two most recent stay mounted, the rest leave the page 3 s after they park
• Untrack src/main/server/media: two unreferenced files from another session were staged by mistake in a76e154
• Tool summaries and captions removed: opening a transcript no longer boots one CLI per collapsed section
• toolDetails: one comment on rec() — frees the release train that has been skipping since v105
• One-shot model calls boot no MCP servers and run two at a time: tool summaries and titles stop forking a CLI plus every configured server per collapsed row
• Engine loop closed: an errored language server stays errored for the crash window, and an expired intellij-server build retires itself
• Helpers die with the app: server close, before-quit, process exit and signals kill every tracked child
• Every helper process goes through one budget: four at a time, the rest queued, each with a timeout
• Only the active project asks git: rail diff stats for the selected card, branches for the live composer, file index and slash commands when their menus open
• Inbox fetches only while open, one gh call at a time, this project first: the rail badge reads the cache and never polls
• Window stays opaque: vibrancy only with TEMP_CODE_GLASS=1, mac root gets a solid background
• Focus gets a store, and App.tsx is composition over the stores
• The terminals, the editors' state and the title bar's projection get stores
• App's tab actions and its store-driven effects move out of the component
• The window's open tabs live in their own store
• The window's workspace, project and recents live in their own store
• The window chrome reads its own store, and the workspace is planned before the first render
• The release worker finds node
• The release gate runs its checks in a plain environment
• A parked tab keeps its layout: content-visibility hidden instead of display none
• Server-made threads open behind the user's work, and a project or workspace lands on the thread it was last on
• The sidebar virtualizes its cards, folds empty themselves after closing, and rows keep their identity across meta pushes
• Timers tick in the leaves that print them, the sidebar reads one meta store, and a streamed event allocates no shells
• The composer reads its box in one walk, keeps typing out of React, and turns a big paste into a file
• Focus and tab-switch no-ops stop re-rendering the shell; the workspace autosave never loses a save
• A jsdom test tier for the renderer: render probes, library stubs and per-component render tallies
• A headless boot benchmark, so the startup work can be timed without an app
• The project rail shows a thread that needs you, not just one that is working
• spawn_agent and app_start_thread can ask for the 1M window
• Codex threads get the app tools in the packaged app: resolve the bridge from the app path, run it under node
• Prod moves to the stable branch (v96 line); master keeps the new shell. bun run dev:prod runs master on the prod data for the user's own testing, and CLAUDE.md records the two lines and how to move prod over
• Boot profile fixes: decorate checks continue-ability off the meta it holds instead of a getSession per session; Store caches prepared statements; tool summaries humanize ids from raw rows (memoized) instead of decorating the whole list per prompt; WS requests over 500 ms and sweep progress land in the boot log
• Overlays stop flashing: one glass surface, promoted to its own compositor layer
• Mirror backfill skips mirrors newer than their thread, yields per rewrite, writes INDEX.md once, and runs after the fold sweep instead of on its own 5 s timer
• Sidebar folds are persisted: list() reads session_folds instead of walking every event log; append() keeps rows current; a chunked, yielding boot sweep heals missing or stale rows newest-first and pushes each row live
• session_folds table and store API (listFolds/getFold/putFold/deleteFold, maxSeqs, eventsRange, FOLD_VERSION) under test — nothing reads it yet
• Unread survives the cutover: adopt the old last-seen map, floor the rest
• SessionRegistry.get(id) and childrenOf(parentId): every lookup-by-id that decorated the whole list now decorates one session (mirror, app tools, orchestration, WS callers, summarize)
• decorate() is linear: list() builds byId/byParent once and shares them; summarizeRootTree takes the prebuilt index; sessionTree uses it too
• Boot timing log: bootMark() writes ms-since-start marks to /tmp/temp-code-boot.log for server-start, db-open, first session.list and the mirror backfill
• Window and dialog titles say TempCode, not MonoCode
• M12: multi-window and window transfer — a window registry in main routes menu, PTY, appshot and update traffic to the window that owns it; each window persists under its own slot and the transfer slot is scoped to its destination; close hides when busy or persists then destroys, quit gates on the focused window and waits for the rest; Cmd+Shift+N runs through the command map, the menu tree and
• M13: scripts/release.ts gates on vitest run between typecheck and build, so a red test blocks the release train
• M13: drop the old renderer's dependencies nothing imports (radix-ui, base-ui, dnd-kit, headless-tree, tanstack table/virtual, react-markdown, remark-gfm, lucide-react, cva, typography, zustand, xterm addon-fit); clsx and tailwind-merge stay for motion/cn.ts
• Codex threads get a task list again: the app bridge carries an update_plan tool (Codex dropped its native one for goals) and the driver surfaces it under the bare name so the implementation board renders for gpt-6-astra
• M8e follow-ups from the exit test: symbol kinds index SYMBOL_KINDS by the LSP kind (a class showed as PACKAGE), in-memory search hits carry seq so a loaded thread jumps too, only the shown pane takes a transcript jump, and a search hit or focused thread from another workspace brings that workspace forward
• M8e: one command map for keys and menu, session.search over the event log, scroll-to-seq, window.__app facade, badge counts waiting threads
• M8c: fresh drafts survive the idle sweep, global defaults name the overriding workspaces, a dev-only next-pick seam for the folder dialog
• M8d: Fast rides on the user-text stamp and shows in the turn meta; queue.update patches through a field helper; a model pick retunes the live thread's Fast and 1M to what the composer now shows
• M8c: App wiring — drafts seed from thread defaults, typed threads are server-backed from the first click with their rules, new folders open the New Workspace dialog
• M8d: managed composer with connector chips, per-thread drafts, lightbox, queue tune fields, Fast/priority and cross-provider model search
• M7b: gitIndexStore holds one snapshot per checkout behind a hold/release API, with a test for the watcher-driven reload and in-flight coalescing
• M8c: thread defaults model, turn-pass fields, workspace/project dialogs, workspace settings pages, labels keyed by workspace id
• M7b: file tabs show the file's +/- from the index and the LSP-busy line at the strip's edge; the file tree walks with arrow keys, Home/End and Enter, and the root row joins the tree
• M7b: the rail's Changes tab runs on the server's git methods — staged and unstaged sections, per-hunk staging, discard, stash, pull and push, commit the index as-is, recent commits from git.log, rows open the file against HEAD; the snapshot refreshes off the server's tree watcher, never a poll
• M8a: appshots renderer — routing, staging, settings page, fly-in, shutter
• M7b: the debugger lives in the rail's Debug tab — docked DebugPane goes; breakpoint changes sync the changed file so a cleared last breakpoint reaches the debuggee
• M6d transcript: one scroll engine (follow spring, parked runway, glide, jump pill), runway retires on settle so anchored turns leave no blank space, tail Thinking shimmer, persisted folds with 200 ms tween and second-call auto-open, hover timestamps, minimap, todo list row, code blocks with copy and IntelliJ themes highlighted in a shiki worker
• M4b slice 3: cold launch fetches only the active tab's transcript before first paint (other restored tabs carry their meta and load when their pane mounts in an idle slice; an unloaded session is never treated as blank); AgentTranscript renders turns through a memoised TurnList/TurnView over stable turn arrays so a streamed delta re-renders the live turn alone and a re-shown pane renders no rows
• M5d: memoize the rail host so a thread switch does not re-render it
• M4b slice 2: App reads session shells, not sessions — title tabs, thread strip chips, plan readiness and the active thread's cost move into chrome/ShellTitleBar.tsx; rail live cards and finished-while-unfocused tracking into lib/liveAgentTracker.ts; busy project dots into hooks/useBusyProjectPaths.ts; hidden approval toasts, dock badge, idle-session sweep and auto-continue run off store subscr
• M6c: subagent links in tool rows open the pane's AgentDetail too; MCP tool names in the context breakdown drop their server prefix; TEMP_CODE_AUTO_COMPACT_WINDOW lowers claude's auto-compact window for dev exit tests
• M4b slice 1: per-session selector hooks — useSession, useSessionMeta, useSessionStatus, useSessionBusy, a stable useSessionIds and useSessionShells (open sessions minus transcript/busy/thread state, same array through streamed turns); PaneTree leaves subscribe to their own session instead of taking the sessions array; ErrorRowView reads one meta
• M5d: project right rail with Changes, Files, Branch, Build tabs; build settings page and project override; review-with-base seam
• M6c: connector and subagent chips, nested agent rows — addon calls lead with the connector's brand and proper name, a Reconnect chip opens the sign-in page from the fold's reauth (on the row and on a folded group's header), a user's /command reads as the addon it names; subagent calls lead with the provider and count the steps run under them; spawned/report events render as nested rows that op
• M6c: context meter moves to the composer bottom bar beside GoalControl — ring and percent from the fold's live context, click opens the /context breakdown (categories bar, memory files, MCP tools) through M5c's shared session.context cache, polled only while open and the turn is settled; the cache's reading carries the breakdown
• M6c: compaction card — the fold keeps the compaction lifecycle on its system row (start time, trigger, pre/post tokens, duration, error) and drops the context meter to postTokens on done; CompactionCard renders the pulse and estimated bar while it runs, a before/after divider once it lands, a red line when it fails; nested steps carry parentCallId and count on the spawning call; spawned/report
• M5c: on the merged branch — Implementation reads M4's explicit session.loaded bit, QuestionCard slides its pages by default through slideQuestionPage, and the Plan Start tune subview rides M5b's ThreadTune (one tune subview; OrchestrationTune and its test are gone)
• M6b: timed-out approvals key off M4's auto flag now that fold records them as deny
• M5b: wire the thread header into the deck title bar and App on M4's shell — App builds the header model from the selected project's root threads, archives select the neighbour, chip actions go through M4's pause/resume/interrupt/setThreadRules/pauseAllRunning wrappers; the donor ThreadStrip and its model are gone
• M6b: a decided approval keeps its verdict line under the tool row (denied / denied (timed out) / approved)
• M6b: timed-out approvals read denied (timed out); a decided board's verdict shows under the edit row it judged
• Live change stream: a session awaiting approval keeps its watcher and ownership, so the write that follows the answer is attributed and checkpointed
• Server: a supervised disk tool call stays open across its approval wait, so a write approved after the grace still owns its live edit and gets checkpointed
• M5b: tune and delete dialogs name the chip by its display title
• M4 perf: coalesce streamed pushes per frame, stage hidden pane mounts, shield opened history sessions from the hidden sweep, cache per-render session scans
• M5b: chip labels use the display title so a placeholder draft reads New session
• M6a: the inspector reads a streaming call's partialInput until the full input lands; Block.tool gains M4's partialInput, display and reauth fields (same text as M4's hunk, added here so the merge stays clean)
• M5b: a local draft is new, not unread
• M6b: a user Stop stamps its error row (Block.stopped from the error event's stopped flag) so earlier Stopped rows stay gray after a later failure; the error chip reads treeCanContinue from the meta until the session projection carries it
• M5b: header model owns its neighbour rule; drafts carry threadRules and a minted createdAt through session.create
• M5b: ThreadHeader — chip menu, rename, tune and delete dialogs, cost, Pause all, rail toggle
• M5c: SessionPane hands ThreadView renderSlots (transcript, strip, composer) beside renderChat so Orchestration seats the composer under the hero and the log in the side panel; edited donor files back in the donor's style (the project prettier config had re-quoted them)
• M5b: ThreadHeaderStrip — project root threads as soft chips on M5a's Tabs (pointer-down select, gliding wash), tone washes, live row and shelf, archived shelf, new-thread slot
• M5b: new-thread chooser popover with every thread type, hints and a tune view for orchestration and research
• M5c: question card keyed page slide — slideQuestionPage for QuestionCard's renderPage seam (M6b), reduced-motion aware, unit test
• M6b: wire turn state into the transcript and composer — live TurnDuration on the shared clock (paused holds), error rows become Stopped/Failed chips, pass rows compact, approval detail and outcome under the board, section summaries and captions in phase groups, GoalControl in the composer bottom bar
• M5b: per-thread tune editor (ThreadTune/TuneDialog) on the donor's settings primitives; override keys drop at the base value, empty tune saves as null
• M5c: Implementation change rows morph into their card inside a per-mount LayoutGroup, task/round/disk bodies fold with measured TweenHeight, closing note and fresh edits rise in; Research angles open the agent's detail in place
• M6a: wire the inspector, per-file edit cards, app-tool titles, file-ref menu and copy-message into the transcript, markdown and composer
• M5c: fleet panel rides useFleetModel — opens while a child works or waits, slides 0→340 with presence, rows show task percent and compaction over the polled context ring, detail morph scoped per mount; Orchestration docks its log in a folded 380px SidePanel with the composer under the hero
• M6b: QuestionCard steps one question at a time (renderPage seam for the page slide), GoalControl popover for the composer, ErrorChip for Stopped/Failed rows; Target and StopCircle icons
• M5c: Plan Start button springs in and out with presence; Orchestrate row opens a tune subview whose per-run instructions and conduct overrides ride threadRules
• M6b: turn-state logic as pure modules — section summaries/captions over tools.summarize (settled groups only, cached, never re-asked), one shared clock over busySince, Stopped-vs-Failed rows, question stepper, goal control model, approval detail + outcome wording; unit tests
• M6a: tool-details inspector, per-file edit cards, app-tool titles, isInternalPath, FileRefMenu and copy-message as new files with unit tests
• M5b: sidebar project card keeps temp-code's layout on MonoCode tokens — always the summary, selects on pointer-down, sidebar-active wash, tree-aware paused/running/unread lines with tinted matrix spinner, thread glyph, frozen elapsed and implementation tally, whole-card state tooltip, temp-code's menu (Rename, Settings, Continue/Pause, Stop, Archive with worktree wording, Delete) with New chat
• M5c: OrchestrationTune — per-run conduct overrides and instructions over the Settings defaults, with tuneSummary for chooser rows
• M5c phase 1: fleet model hook with panel open rules and stats parts, per-session session.context poll cache (20 s, ref-counted), chat column slots so views can seat transcript, strip and composer apart; unit tests
• M5b: strip, header, project-card and right-rail models — temp-code's live/dormant rule over project roots (loose chats out, drafts live, done settles), tree-aware chip status and tone, header model mapping chips to workspace tabs with neighbour selection, ProjectRow's ordered paused/running/waiting/failed/unread passes with tooltip and menu copy, session-scoped right-rail open store; unit test
• M5a: TweenHeight really tweens — the height lives only in the layout effect, since a style prop let React commit the target before the tween measured and the fold snapped; regression test
• M7a: rename falls back to the file's standard server, reopened files keep cached diagnostics, watched-file changes reach jdtls/vtsls, and a server that dies before initialize is not re-ensured
• Selecting a project closes the inbox, notes and search views so its pane always shows
• M8b: prefix numeric provider versions with v; hint says TempCode
• M5a: unit tests for TweenHeight timing, diff-row adapters and the persisted open map
• M5a: code dropdown — TweenHeight fold, persisted open map, timed reveal/hold, diff-row adapters, inline Monaco editor swap on EditRow
• M7a: IntelliJ feel and editing lifecycle — JetBrains Mono, IDEA completion/hover CSS, theme recompute on tint, focus boot, server-watcher subscriptions, review dirty/conflict, autosave-off, rename/move carry, editor-scoped ⌘P/Ctrl+T/Ctrl+D/Find
• M4: transcript store and shell fixes — seq guard on replay, held pushes during history fetch, re-subscribe on reconnect, approval binds only its own call, auto-deny recorded as denied, open tools settle when the turn ends, pause stamps duration, cleared errors clear every system row, history images load, normalized patches keep their diff; queued and steered messages carry provider/model/effor
• M8b: settings pages, updater panel, archives, Codex usage footer
• M5a: dialog and menu motion — Modal traps Tab, restores focus, guards dismissal while busy and ghosts out over 120ms; popover enters in 140ms and ghosts out in 100ms
• M5a: callers adopt the motion vocabulary — composer Pause tint and press, attachment chip enter/exit, drop overlay fade, keyed session reveal, sidebar width spring with rubber-band resize, matrix alpha .15, flash colour
• M5a: motion primitives — ease vocabulary (SWAP damping 30), Button/ButtonLink press + ripple, StatefulButton cascade, Collapse, Tabs shared indicator, TextShimmer, TweenHeight, useHoverCapable
• M10: five second-class providers (grok, opencode, pi, omp, fx) ported from the fork server into src/main/server/drivers with their tests; registry gains requestApproval (approval-request/waiting → approval-resolved/running, 5-minute auto-deny, denied on handle drop and shutdown); catalog/doctor cover all eight providers so a missing binary hides the harness; catalog.get {refresh} re-probes the
• M2b: renderer bridge fills every native command over preload and the server client
• M9: back the six session_checkpoint_* native commands with the checkpoint.* WS methods via an injected server request
• M9: per-session undo checkpoints on the server — checkpoint.{ensure,capture,sync,status,undo,keep} WS methods port monocode's checkpoint.rs (manifest under userData/checkpoints, 500 paths / 8 MiB limits, same-cwd claims, per-session serialization), ensure arms before every harness send, vitest restore suite and a WS e2e script
• M11 bridge: the seven linear_* commands route to the server; link.ts binds the WS client into native.ts at boot
• M11 server: Linear GraphQL client and WS methods (linear.status/setToken/teams/issues/details/thread/comment)
• M2a: exit test over CDP; lazy tty lookup, spawn-helper exec bit, CORS for the asset scheme
• M3b server: 13 fs path methods (absolute/home paths, 8 MiB text and 20 MiB base64 caps, atomic writes, case-only rename), donor-semantics git read (diffStats/diffIndex/fileDiff with HEAD base/stagedContext/rangeContext/branches) and write (clone/stage hunk via stageContents/unstage/discard/stageAll/unstageAll/commitStaged index-only/push/pull/sync/checkout/createBranch/stash) plus git.log, GitHu
• M3a server: session.pin (persisted pinned column + migration), text.generate, caller-chosen session ids, workspaces/projects catalog pushes, path-only session adoption, isPlaceholderTitle; workspace.get/setSnapshot in the settings KV (2 MB cap); notes table CRUD with slugs and caps; search.project (git grep with file-scan fallback, 500 rows); projectLogo.save/remove under /project-logos
• M2a: native shell — pty host, app menu, window facade, dialogs, asset protocol
• M1 scaffold: MonoCode's web layer (donor 105610f) becomes the renderer — src/renderer/src replaced whole, lib/native.ts closed command map over window.api (unbacked commands reject 'not ported'), boot script externalized for CSP, donor deps added, tsconfig.web at donor strictness, vitest wired with the bridge mocks
• Vitest scaffold at the repo root (transplant branch): src/**/*.test.ts(x), @shared and @Renderer aliases, node environment
• Build tab: the chosen branch shows how far behind origin it is (and when origin has unfetched commits) with a Fetch button that streams git's progress and fast-forwards the branch where it lives; diverged branches fetch but stay put
• Build tab: pick which branch to build without switching the project checkout — another checkout builds in place, an unheld local branch builds in an app-managed detached worktree under ~/.temp-code/builds
• Right rail: Branch tab (compare, update from target by merge/rebase, merge into target; conflicts abort and list files) and Build tab (streamed build log, outputs revealed in Finder, per-workspace/project build command with detection)
• Add GPT-6 Astra (gpt-6-astra) to the Codex model catalog
• Restore the task board on new-model claude sessions (CLAUDE_CODE_ENABLE_TODO_TOOLS)
• Provider update buttons in Settings; claude sessions use the newest installed CLI
• Add Claude Fable 5.1 (claude-fable-5-1) as a spawnable model
• Worktree project edits render as real file cards, not app bookkeeping
• Wheel-scroll thread tabs, Stop for paused threads everywhere, chats sort by activity, right-click file links
• A thread whose project worktree vanished remakes the checkout instead of dying
• Research threads: fan-out web research with a live sources board, and durable cited reports every thread can find
• 1M context works again: the [1m] model suffix replaces the beta header the CLI drops for subscription auth, and a fast/1M toggle no longer wipes the other flag
• Failed means failed: only a thread's own trailing error shows red, a Stop reads as Stopped, and old stop errors heal
• release 82
• Deleting or archiving a running thread stops it and its whole fleet; orchestration rule changes reach a running orchestrator
• Full-access Cursor subagents run with the sandbox explicitly off, so a stray cursor config can no longer confine them
• release 80
• Standing a Cursor agent down no longer marks it failed
• Threads get 10k more room before they compact, so long sessions summarize themselves less often
• Seeding a thread from another costs a fraction of what it did: the digest keeps the outcome and the latest turns, and links the full transcript
• A thread starts by looking things up, not by reading the whole project: the context block points at the index and the journal tail
• The project journal stays short: entries past 6 KB move to PROJECT-archive.md, newest kept in place
• A thread can find past work by file: every transcript names the files it touched and its outcome, and threads/INDEX.md lists them all
• A Cursor thread can run the commands its access allows, and its shell output reads like a terminal
• A thread that is working again stops calling itself failed — live work outranks an error it already moved past
• Cursor threads group work under its task list, and every file it writes shows the file and its diff
• A Cursor thread keeps the message you sent it and says its answer once
• Cursor works again — cursor-agent is found even when its bin dir is only on the interactive PATH
• One Pause all button in the title bar stops every working thread — it shows only while something runs
• Threads can be paused and errors cleared from one place — a banner under the title bar gathers every failed and paused root, Pause replaces the empty composer's action on a live thread, and paused work keeps a frozen clock until Continue
• Tab status washes hold up in dark mode — the bright 400-series tokens step up to 15/20% alpha there, mirroring the code-wash precedent
• Projects in a workspace no longer blend together — each row wears a faint enclosing rule and the stack gains breathing room between cards
• Watchers cost one fd per tree, not one per file — v70's fd-limit raise let per-file kqueue watchers starve the system file tables (network down, reboot); recursive fs.watch rides FSEvents on macOS, the raise is reverted, and both livediff and the file rail share the new treewatch
• Creating threads and projects no longer dies with spawn EBADF — the main process raises its fd soft limit at startup (live-diff kqueue watchers cost one fd per file and two worktrees filled Chromium's 8192 default), and live watchers key by resolved root so they always close
• Faint rules bracket a project card's active-tab lines and separate them from each other, even when only one thread is live
• Project switches stay smooth and finished plan threads open plan-only — the thread view swaps on a deferred id with the history fold published in a transition, restored plan docs skip the growth animation, and a settled plan auto-collapses its chat (reopen from the edge button)
• Thread tabs wear a status wash — amber when a thread needs you, red when it failed, blue when it finished unread — so attention states read at a glance
• Loose and workspace chats in the sidebar dress like project thread lines while working — tinted spinner up front, current activity as the tooltip, elapsed time on the end — and show the blue dot with a bold title once finished unseen
• Subagent settle reports go straight to the parent harness, never through the chat — the queue no longer shows them, no user bubble renders, and a slim divider records the wake; busy parents get parked reports at settle, ahead of queued messages
• Reopening the folded chat is smooth, and a queued message starts the next pass
• Agent detail morph stays smooth while the agent streams — the transcript mounts only after the row-to-modal morph settles and unmounts before the close morph, keeping the shared-layout spring's subtree light
• Approved subagent models: per-model approve switches and reasoning min/max ranges in orchestration settings, enforced at spawn — unapproved models are refused, efforts clamp into range, and prompts only advertise approved options
• Project rows count only what they don't already show — the bottom line reads dormant and archived tabs, not every open tab, and disappears when there's nothing quiet to count
• Sidebar thread lines carry their thread-type glyph — the tinted type icon sits between the status indicator and the title, same idiom as the tab strip
• Project settings from the three-dots menu — rename, switch or create the worktree's branch, and set a per-project completed-turn override
• Sidebar thread lines lead with their status — spinner or unread dot up front, elapsed at the end, and the task tally moves down beside the current task's name
• Sidebar project rows name the task a working implementation tab is on — an indented line under the thread shows the in-progress task, folded server-side with the tally
• The context ring is live — it moves as replies stream, on every thread, and the breakdown only shows when it is current
• The project card names its running and unread threads — each line wears its tab's own indicator
• Tab clicks stop bouncing; the sidebar pill glides clean across workspaces
• Coming back to a finished implementation thread opens on the board — the chat starts folded
• File callouts land on their line lit — the wash fades once you've found your place
• A continued run stays Working — a dropped handle can no longer stamp its dying error over the fresh status
• Coming back to a project reopens the thread you left open, not the newest one
• Goal mode on both harnesses — set it, watch it, and the met row clears the ◎
• The open diff leaves the grid — siblings close ranks, the card morphs both ways
• The Continue button reads the transcript, not the status — idle threads with trailing errors get it too
• Shell edits belong to the thread that made them — ownership at the source
• An errored turn is not a completed turn — and the pass admits unfinished work
• Errored threads grow a Continue button — clear the chips, pick the work back up
• Copy buttons on transcript turns — prompts paste back with attachments intact
• The project's branch and completion settings now outrank any skill's git flow
• Standard-mode threads compact before the window slams shut, and recover if it does
• A finished plan holds the top row wearing a violet Plan ready badge
• Starting a build from a plan lets you pick the context window
• Subagents can no longer slip through the SDK's renamed Agent tool
• Planning threads get the fleet too; the panel becomes one shared component
• A second project on the same checkout no longer wipes its journal
• Implementation tabs count their tasks, and the clock never gets cut off
• Pass colors are fixed to the pass number — pass 1 is always green, pass 2 sky
• Selected tabs stay on the dormant shelf; the pass banner is one clean clickable tab
• Dormant threads no longer snap to the bottom of the chat while you read them
• Dormant threads get their own shelf under the working row
• Pass tab rides inside the composer's own column — it can never cut into the pill again
• Sidebar, rebuilt: repo logos, tab counts and live states on every project, drag to resize or collapse (⌘B)
• Chat threads grow the fleet panel: spawning slides the chat left, Subagents ride the right edge
• The strip separates now from later: live tabs lead, dormant ones recede
• Known services wear their face everywhere, not just codex connectors
• Click any image to view it large: lightbox over composer tiles and transcript thumbs
• Working tabs slim down: the verb, not the sentence
• Every new pass re-arms the task-list contract in-band
• Pass banner becomes a composer tab — same width, tucked behind the pill, text action
• Pass boundaries are explicit now, and other actors' shell edits stay off the board
• Composer image previews: data URLs instead of CSP-blocked blob URLs
• Orchestrators editable from their tab; working tabs hold still and color their work
• Pass banner: every pass wears a color, the next one starts by its button, composing runs full screen
• Project teardown survives already-gone branches; engines stop before their worktree is removed
• Per-run orchestration tune: custom instructions + rule overrides at start
• Dark-mode diffs get their dark palette back
• Worktree creation survives stale dirs; archive projects with optional git cleanup; per-project completed-turn override
• A pass only ends when its work does: continues and post-halt resumes never start one, timers count work not waiting
• Live-diff watcher refuses cwds that would freeze the app: non-repos and 30k+-file repos
• Every send stamps its run settings — pass history names the model, effort and window that did the work
• Thread tabs tell you everything at a glance; SDK pinned back to 0.3.227
• New project dialog redesigned: segmented mode picker, quiet branch suggestions, footer band
• Passes carry their record: Pass N, finished when, how long, what ran it, what it cost
• Threads change type mid-conversation: a composer picker retypes the thread and re-instructs the model
• Projects pick their branch; workspaces gain a completed-turn pass the transcript sets apart
• Task lists survive the Fable-era CLI: preambles name the real tools, supervision reads TaskCreate
• The window switch returns as a real control; packaged menus get their glass back
• Boot reset writes the closing status event a dead process never could
• Board diffs go dense, shell edits open and join the summary, the chat pane follows the run
• Rogue dev instances can no longer freeze prod threads; window truth is the catalog
• One-off chats: workspace chats outside projects, loose chats outside workspaces
• Board: previous passes tuck into collapsed rows, wide break before the current work
• Appshots: captures ship as ≤1600px JPEG the model can actually see; stub trees say so; never shoot our own window
• Follow-up rounds: each request is its own board section, timers never bleed, stops don't fold the chat
• Window switch in every claude chat, drafts survive navigation, no more stuck working
• Appshots: Codex-style capture landing — flash, hold, fly into the composer chip
• Appshots: AX dump gets hierarchy — containment indentation, [role] tags, and an .md header pointing at the paired screenshot
• Appshots: tool calls reading appshot files render as 'Read appshot'
• Board round 5: diff reveal on land, whole-file changes, real Java highlighting, gliding timelines, h/d timers, auto-fold chat
• Appshots: monitor exits itself when the app dies without will-quit
• Appshots: settings page — enable, destination, sound, permission rows
• Kill the board's residual jank: rigid rows, sliding card, mid-flight tweens
• Board motion: locked layout, per-mark timeline popup, time leads files
• Board polish: standing wash, floating legend, close-is-collapse
• Active window shows as a check; the context popover never spins forever
• Task board: quiet washes, text-row changes that morph open, legible timeline
• Window switch lives in the thinking dropdown; the context meter runs live
• PLAN-5 M22–M25: live change streaming and the self-explaining task board
• Context meter reports the real 1M window on current Claude models
• PLAN-5: live change streaming and the task board that explains itself
• Appshots: composer chip, delivery routing, shutter sound, transcript
• Appshots: main-process capture pipeline + preload API
• Appshots: attachment kind, send-time expansion, settings RPC
• Appshots: double-⌘ hotkey monitor + swiftc build step
• Appshots groundwork: native capture helper (capture + permissions)
• Connector chips in the composer itself
• Connectors lead the / menu and wear their product names
• Slash menu sections + scrolling; connector faces on single rows; pretty refs
• Reconnect chip surfaces on the collapsed tool group
• Connector reauth becomes a Reconnect button
• Codex threads route through Aliax again — the overlay home is gone
• Codex threads run on an overlay CODEX_HOME so connectors reach the model
• Confusion is a blocker: implementation threads ask instead of guessing
• Implementation threads can start from scratch — recon, then tasks
• Codex first turn waits for MCP startup; plugin refs name their prefix
• Background IntelliJ index warming: projects index silently on startup, after commits, and on create; focus-boot on project switch
• Parameter Info, Code Vision, Show Usages, smart backspace — the IDEA set
• Addon tool calls wear the Codex app's own face
• Codex gets its whole toolbox; addons are first-class slash references
• Fast in-place updates with real progress; slash skills anywhere again
• Typing ) skips the auto-inserted one; ⌘P is Parameter Info
• Stop tracking tsbuildinfo caches
• Update button shows live progress
• Releases cut themselves: post-commit auto-release on master
• The type column pins to the right, IDEA-style
• The engine survives reality: reloads, .idea repos, and the exact IDEA popup
• CLAUDE.md: prod data stays under the temp-code dir
• Burn the runAsNode fuse in packaged builds
• lsp: in-progress editor work from parallel session
• TempCode: self-updating installed app + release flow
• Codex task lists reach the board — turn/plan/updated was dropped
• Summaries wait for the section to finalize
• Summaries speak plainly, caption every tool, and pick their model
• Settled tool sections get a model-written sentence
• No minimap in split chat panes — it overlapped the text
• Implementation goes phased like planning; the ring reaches the fleet
• A section's first tool stays folded — auto-open waits for the list
• The active tool group rides open; the next text block folds it
• Dormant supervision, richer agent telemetry, work filed under its task
• M21: update channel, Settings polish, PLAN-4 amendments
• M20: the debugger — IDEA's XDebugger through DAP
• Detail pass: modals, archived viewer, new-thread menu, workspace settings
• M18+M19: hierarchies, decompiled sources, and Kotlin
• M17: the read side answers from IntelliJ
• M15+M16: the IntelliJ engine — ranked completions, inspections, intentions
• Hidden reasoning is a trailing status, never a row that vanishes
• Codex's native GPT-only fleet is off — spawn_agent means the app's
• PLAN-4: the IntelliJ engine — intellij-server across the whole editor
• Threads verify spawning themselves instead of trusting stale blockers
• One working clock everywhere, plus per-section timers
• spawn_agent forgives what models actually send
• Every builder spawns subagents the same way — and never via a CLI
• Fast mode for codex threads (priority service tier)
• Inline editor reveals reliably; the diff refreshes after a save
• Inline card editor washes the model's changes; ⌘S saves back to diff
• Completion turns IntelliJ: real ranking, postfix templates, IDEA popup
• Diffs get line numbers and context; the dropdown edits in place
• File edits never collapse; app bookkeeping stops posing as file edits
• Answers to stale questions land instead of vanishing
• Models may batch questions again — the stepped card owns the pacing
• Question cards step one at a time, whatever the harness batched
• The editor turns IntelliJ: Darcula colors, semantic tokens, Alt+Enter
• Context meters for every provider, live window switching, distinct compaction UI
• Start knows who builds; models route to their harness; plans wrap cleanly
• Plan threads: chat-first phased view, and questions that reach the UI
• Fast mode, context window, and the /context meter in the chat bar
• Message queue + steering: mid-turn messages wait their turn, or don't
• Every tool expansion is pretty by default, verbatim behind one toggle
• App tools and thread mentions render human — titles, never ids
• Files tree opens on click; IntelliJ double-Shift finds files
• Settled turns fully release the runway — no phantom bottom space
• Tool groups summarize what happened, not how many commands
• Files, editor, LSP, shared context, supervision, chat polish
• Transcript minimap: a real map of the thread
• Settings gets real material: grouped panels, depth, one hierarchy
• Settings pages + thread defaults with workspace overrides
• Thread strip: live status, activity order, unread dots, rename
• Default rules mirror the user's model policy
• Orchestration rules are real settings: structured, enforced, baked-in spawning
• Orchestrator rules: user-editable policy, provider-switch wire, e2e
• Model questions are first-class: structured multichoice prompts, answered
• Thread views: work-first heroes, right-side log panels, real task model
• Sidebar navigation always leaves the settings page
• True model catalogs from the CLIs, per-model reasoning ladders
• Cross-provider model picker, settings page, color, sidebar rhythm
• Zeron menu language, chip tabs, thread archiving
• Stream tool input live into edit cards
• Fix scroll engine and section toggles
• Smooth streaming: reveal buffer for text, spinner-first tool chips, count-up diffstats
• Theme-aware tool surfaces + standout edit cards
• Zeron look: exact port of comet's chat design onto the transcript stack
• Skill references work anywhere in a message, any number of them
• Humanize commands, real code blocks, instant send, codex skills
• Chat streaming pass: thinking states, humanized tools, edit cards, refs, autocomplete, attachments
• Second detail pass: pointer cursors, 13px overlay scale, concentric menus, drill-in + selection-pill animations
• Refine the whole interface, per-message model/reasoning, animation pass
• L2-L6: the primitive layout — sidebar, thread strip, four thread views, changes rail
• L1: workspace/project/thread domain — schema, contract, git worktrees, thread preambles
• Rework plan: todo-first implementation view, planning threads, ADE surface model
• Add UI component plan for the primitive layout
• Add Cursor-like light/dark theme tokens, OS theme sync, and design-system doc
• Fix StrictMode double-init and codex resume of turn-less threads
• Fix CSP blocking the renderer's WebSocket to the local server
• M6: orchestration — MCP toolset, router rubric, worktree isolation
• M5: codex + cursor drivers verified live, doctor checks
• M4: approvals — canUseTool → approval card, per-session policy
• M3: transcript surfaces — incremental folding, markdown, shiki worker, chips, virtualization
• M2: session lifecycle — archive/delete/restart, idle disposal, status strip, cwd picker
• M1: verify Claude driver against the live SDK stream
• Scaffold: Electron shell, typed WS server, harness drivers, UI system