What's new in Codron

EARLIER · page 2 of 5

1. v0.10.8Jun 26, 2026The 0.10.7 blank-preview fix, finished: the reload button and the first dev-server start now actually paint

   • · Starting a frontend dev server now paints the preview on the first try. 0.10.7 simplified the preview to 'just reload the page on every tab entry', which fixed the blank pane when you switch tabs and come back, but left two paths still broken. The real cause of a blank pane is the native preview surface getting allocated a beat too late, so the very first page load can finish painting before there's anything to paint into. Switching tabs cured it because that re-seats the surface; the first load never did. Now the first successful load re-seats automatically, once, so the page shows up without you having to switch away and back.
   • · The reload button can now recover a blank pane. It previously just re-fetched the page into the same dead surface, so when the preview was blank, clicking reload did nothing visible (the exact thing you'd reach for first). It now does what switching tabs does (re-seats the surface and reloads), so one click brings the page back.
2. v0.10.7Jun 25, 2026Preview, DEV SERVER, and SHARE rows stop drifting from reality; the live activity log gets per-tool icons

   • · Preview no longer sits blank with the dev server visibly running. The pane had two layers of rescue logic (a 30-shot retry budget on the renderer side, and a 'invalidate the compositor surface a few times across rAF and hope a repaint lands' code path on the Electron side) that worked unreliably on tab re-entry. The symptom: the DEV SERVER strip shows READY with a green dot, the URL is filled in, and the preview area below stays black until you stop+start the server. Both rescue paths are gone now; landing on the preview tab (or the dev server transitioning to ready) just reloads the page. The reload button does the same thing it always did.
   • · DEV SERVER and SHARE rows resync themselves when you come back to the window. Both used to fetch state on mount and otherwise ride a realtime channel. If that channel dropped an UPDATE (laptop sleep, a wifi blip), the UI stayed pinned to the last status it saw, sometimes showing READY localhost:3000 with a Share URL long after the agent had actually stopped both. Stop clicks on a phantom-running server then read as 'no reaction' (correctly: there was nothing to stop). The cards now refetch fresh state whenever the window regains focus, the tab becomes visible, or the network comes back online, so the displayed state can't drift from the actual one for long.
   • · Ctrl+R / Cmd+R reloads the dashboard in the packaged app, too. The shortcut was previously dev-only on the assumption that 'reloading a bundled asset is meaningless', which missed that the actual thing you want to reload is the renderer's cached React state, exactly the situation when a realtime UPDATE goes missing and the UI looks stuck. The shortcut now works in the installed build, so one keystroke forces a fresh fetch. Ctrl+Shift+R force-reloads bypassing the cache.
   • · The live activity panel now has shape-coded tool calls. Every tool used to render with the same → glyph and the same uppercase white label, so a column of Read / Edit / Bash rows all looked identical, and you couldn't tell at a glance what kind of work was happening. Each tool kind now gets its own icon (file for Read, pencil for Edit/Write, search for Grep, terminal for Bash, robot for Task, …) and the tool name renders as a small uppercase chip, so the panel reads as a scannable action log instead of a wall of arrows.
   • · Enter sends in the engagement composer, matching session and scratch. The bottom-of-engagement composer (where you type orders) needed Cmd/Ctrl+Enter to submit, while the session and scratch composers above used plain Enter, so muscle memory inserted a newline half the time. The three composers behave the same way now: Enter sends, Shift+Enter for a newline.
3. v0.10.6Jun 24, 2026Pending decisions surface immediately in feed, the Share button self-heals when its UI falls behind, and small dashboard friction goes away

   • · When an engagement parks on a pending decision, the center panel now jumps you to the feed automatically. Before, if you were on the session tab and the agent halted to ask you something, the screen didn't change: the session sat frozen with no fresh tool rows, and you could miss for a while that the agent had actually stopped waiting for you. The feed is where decision cards live (approve / reject / fill in variables), so it's where you need to be the moment the agent parks. The jump only fires when you're on session (so an intentional move to preview/settings doesn't get yanked back) and only once per decision, so you can still navigate freely after.
   • · The Share button (per-project ngrok tunnel) now self-heals when the UI has fallen behind the actual tunnel state. The button rendered as 'share' even when the tunnel was already live with a public URL, because if the UI fetched its state during the first realtime blip or before the ready event landed, it stayed stuck on stopped. Clicking share was a silent no-op (the agent saw the tunnel already running and returned early without re-publishing the status). Now a duplicate share-click re-emits the current state so the UI flips to the live URL on the next click.
   • · The new-project briefing form no longer pre-checks the optional 'Send Telegram notifications' toggle. The label said optional but the box was checked by default, so projects ended up wired into Telegram you hadn't actually set up. It now starts unchecked, matching the label; check it deliberately if you want pings for that project.
   • · Deleting a project from its page no longer leaves you staring at a half-torn-down view while the delete finishes server-side. The page now navigates back to the overview the moment you confirm; the delete itself runs in the background.
   • · Preview pane retries through Chromium's transient error pages. After a fresh dev-server start, Chromium occasionally reports load success while still rendering its 'this site can't be reached' interstitial; the preview now keeps trying until it actually has your page, so you don't have to hit reload yourself.
   • · Dashboard project list: long project names no longer truncate the tier chip (Free/Pro). The chip lives in its own grid column now and stays readable regardless of how long the project name is.
4. v0.10.5Jun 24, 2026Feed cards drop the per-engagement diff chip; the live activity panel runs leaner under the hood

   • · The +N/-M diff chip is gone from engagement feed cards. It only rendered for a fraction of engagements (an engagement that analyzed, decided, or closed out touched no files, so the chip was usually absent), and when it did show, the raw line count wasn't something you acted on. The outcome chip and the field-report summary already tell you what an engagement did, so the diff number was noise sitting next to the signal.
   • · The live activity panel runs leaner. The right-panel tool stream you watch while an engagement works used to be written to the database row by row (thousands of rows piling up for a view that's only useful while the engagement is live). It now streams over an ephemeral realtime channel instead: you see the same live progress, with nothing persisted afterward. One behavior change falls out of this: open a project mid-engagement and you'll see the steps from that point on, not a replay of earlier ones (the durable record of what happened is still the feed card and its field report).
5. v0.10.3Jun 23, 2026Readability pass: session answers, the live activity panel, and resolved-decision cards all read cleaner; onboarding now installs Node.js when it's missing

   • · The live activity panel reads as a clean action skeleton now. It used to render every tool result verbatim: a Read dumped the file's contents, an Edit echoed a multi-line 'updated successfully (file state is current…)' blurb, and long absolute paths ate the width, so the right panel was a wall of text you couldn't glance at. It now shows just the actions (the tool calls) plus the agent's own summaries, with results dropped (the full detail still lives in the cycle's field report) and long paths collapsed to their last couple of segments. Errors are kept loud. You can see what it's doing without reading a transcript.
   • · Sessions answer in a scannable shape. Comparison-heavy answers (option tradeoffs, scoring formulas, field weights) used to come back as paragraphs you had to mine. Sessions now lead each section with its takeaway and put comparisons, fields, and steps in a markdown table or tight bullets; the chat already rendered tables, the model just wasn't using them. Plus the redundant title bar above each session is gone (the tab already names it).
   • · Resolved decisions stop looking stuck. A cycle that halted to ask you for something (e.g. API keys) kept a red HALT badge on its feed card even after you'd answered and the loop resumed; it read as 'still blocked'. Once you authorize it, the badge is gone; the card just shows the decision and your choice.
   • · Onboarding installs Node.js for you when it's missing. Claude Code runs on Node, so a machine without it couldn't get an engine going. The setup step now detects that and offers a one-click install through your package manager (Homebrew on macOS, winget on Windows), or the download page if neither is present, then has you restart Codron to pick it up.
6. v0.10.2Jun 22, 2026Preview shows single-process apps (FastAPI etc.), decisions open in the feed, sessions answer tighter, and the activity stream reads cleaner

   • · Preview now shows single-process apps. The preview pane was hard-wired to a 'frontend' dev tier, but a lean app that serves its own UI, a FastAPI/Django/etc. backend rendering HTML at / (exactly what the agent tends to build), gets classified as a backend tier, so the preview tab showed 'no frontend tier' and a blank pane even though the app's screen was live at the backend URL. Preview now targets the frontend tier when one exists and falls back to the backend when it doesn't, so a single FastAPI app renders its page (and its start button + share work) right in the preview tab. Two-process apps keep the frontend-preview / backend-api split unchanged.
   • · Clicking a pending decision opens it in the feed, not the default session view. Decisions are acted on in the feed (an env-var request, for instance, has its 'open Variables' and 'approve' buttons there), so landing on the session tab was the wrong place. As a side benefit, any project tab is now deep-linkable via ?tab=.
   • · Sessions answer fully in your language and skip the throat-clearing. A session reply to a Korean question sometimes opened in English before switching, and narrated 'let me check…' right before reading a file. It now answers entirely in the language of your latest message and drops the pre-tool narration; the activity rows already show what it's reading.
   • · Activity-stream and prompt polish: the cycle's first activity row now reads 'engine ready · N tools' instead of the cryptic 'system init', and the agent no longer sprinkles the '§' section symbol into decisions and reports (it referenced plan.md sections by title instead, which also survives section reordering).
7. v0.10.1Jun 22, 2026Sessions show live activity while they work (and answer tighter); freshly created projects read as 'setting up' instead of idle

   • · Project sessions now show what they're doing. Before, a session reply streamed only text, so after the model said 'let me read the project docs' it went silent while it actually read files and searched, and the bubble sat frozen, reading as broken (you'd wait, unsure anything was happening). Sessions now stream their read-only actions as live rows ('read plan.md', 'search "business model"', 'fetch …'), kept visually distinct from the prose answer, with the current action pulsing. Same idea as the activity transcript in the VSCode Claude Code extension: you can see it working through your project instead of staring at a stuck cursor.
   • · Sessions answer tighter. The session is a thinking space, so it's deliberately not the terse build-cycle voice, but its prompt was actively inviting length, so replies opened with throwaway narration ('let me read X first', 'before I look at the plan') and padded out. The prompt now bans that process-narration (the reading shows in the activity rows anyway), leads with the substance, and cuts filler and hedging, while keeping the reasoned back-and-forth that makes a session useful.
   • · Freshly created projects read as 'setting up', not idle. A just-promoted/created project sits in a 'scaffolding' state while the agent lays down its files and prepares the first cycle, but the dashboard didn't recognize that state and fell back to rendering it as amber 'standby' with a warning icon, i.e. idle and waiting on you. Combined with an empty project shell, a brand-new project looked broken right when it was busiest. Scaffolding is now a first-class status (a cyan, animated 'scaffolding' label everywhere plus a 'Setting up your project…' banner on the project page) that clears itself the moment the agent goes live.
8. v0.10.0Jun 22, 2026Every agent cycle now runs on a built-in engineering methodology - systematic debugging, plan-before-build, and an over-engineering audit - with zero setup

   • · The big one: every cycle now loads a built-in methodology layer shipped inside Codron, so the agent works with discipline by default and you install and configure nothing. It distills the best of the popular Claude Code enhancers (superpowers, caveman, ponytail) into Codron's own, tuned for autonomous headless cycles rather than an interactive human at a keyboard.
   • · Three skills the agent reaches for at the moment they matter: systematic-debugging (when a build, test, or run FAILS, reproduce then isolate one hypothesis then minimal fix then re-verify, instead of guess-and-poke patching), plan-then-execute (sketch a verifiable step sequence before a 3+ file or risky change), and audit-over-engineering (before sign-off, scan the diff for premature abstraction, dead config knobs, and defensive code, then delete it or log the cleanup to the backlog).
   • · Two read-only delegates for big or uncertain cycles: an investigator that locates code across a large repo without spending the main cycle's context, and a reviewer that returns an independent fresh-context punch list before the agent signs off on a risky or hard-to-verify change.
   • · How it ships: loaded into every cycle via a bundled plugin, namespaced so it never collides with your own skills and never touches your personal Claude config or your repo. Verified across live cycles producing correct root-cause fixes, real verification (not 'it compiles'), and over-engineering cleanup. The wire-compression proxy 'headroom' was deliberately left out: routing your traffic through a third-party proxy is not something we will turn on by default.
9. v0.9.1Jun 22, 2026Scratch chat: long answers no longer get stuck under a red error badge

   • · Fixed a scratch-chat reply that finished but rendered the full answer under an 'error: chat timed out' badge. Two bugs compounded: the live-streaming body writes were fire-and-forget, and the timeout handler's final write could lose a race with a late streaming write that landed after it, so the error verdict got overwritten by stale full-length text, leaving the answer visible but flagged as failed. The body writes are now serialized through a single queue, so the status verdict always wins and the row settles correctly.
   • · Timed-out scratch answers now keep what they wrote. A long research answer that tripped the wall used to be thrown away whole; now the partial reply is preserved with a '⏱ timed out, reply may be cut off' marker (same as hitting Stop), so you keep the thinking instead of losing it.
   • · Raised the scratch-chat time limit from 2 to 5 minutes, matching project session chat. Web-search-heavy brainstorms routinely ran past 2 minutes and got clipped mid-thought; 5 minutes gives them room to finish.
10. v0.9.0Jun 20, 2026Session chat hardening: streams survive switches, Stop button preserves partial

    • · The big one: chat session replies no longer vanish on session/pane changes. Before, chat state was bound to each SessionView component instance: opening session B in the same pane killed A's running stream and threw away whatever had streamed so far; dragging a tab between panes or going from 4-up back to single did the same; a 'thinking…' bubble that had received no chunks yet would later render as a tiny dot followed by nothing, reading as a disappeared reply. Now chat state lives in a module-level store keyed by session id, so A's stream keeps running in the background when you switch to B, and when you come back you see whatever arrived while you were away (or the full response if it finished). Same goes for split-mode changes, tab drags, and even the same session shown in two panes (both update live).
    • · Send becomes Stop while generating. The transcript-replay model only feeds settled turns to claude, so a second send during streaming would lose the first reply's context AND fork into a parallel claude child the UI couldn't disambiguate. Send now toggles to a Stop button while any assistant bubble is mid-stream; hitting stop freezes the partial as a settled prior turn, so your next send naturally picks up from where you interrupted; no separate 'continue' button needed.
    • · App quit / Cmd+Q / electron auto-update mid-stream still preserves the partial. Pending bodies are normally kept out of localStorage on every chunk (perf: chunks fire ~5/sec, no point disk-writing every tick), so before now a renderer reload between chunks would drop the partial. A beforeunload flush freezes every session's pending bubble and writes once before the JS context dies; same-tab session switches are still served by the in-memory store, this only kicks in when the whole context is about to die.
    • · Scheduler: clean halts no longer read as red failures. The forceStuck path was relabeling the agent's self-declared terminal states (`accomplished`, `standby`) as `pinned`: the red 'needs your attention' badge. That mis-framed two coherent halts: REASSESS at the ambition ceiling ('I'm done, hand it back') and an escalation waiting on your answer (whose own UI already routes you to the decision card). Both states are now guarded before the pinned write; every other halt path still flows through to pinned as before.
    • · Polish: scrollbars are hidden globally while scroll behavior stays intact. Dense multi-pane surfaces (timeline, feed, dropdowns, prose) read as cleaner without the chrome of tracking bars. Wheel / trackpad / touch / arrow keys all still scroll; only the visible track is gone.