What's new in Codron

EARLIER · page 8 of 11

1. 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).
2. 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.
3. 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).
4. 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.
5. 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.
6. 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.
7. 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.
8. v0.8.0Jun 20, 2026Projects stop finishing at v1: an operator-set ambition tier drives a REASSESS pass that keeps finding the next valuable work

   • · The big one: projects no longer park the moment their backlog empties. Dogfooding showed the methodology was quietly optimizing for 'reach a defensible v1 and stop': projects hit a self-declared 'complete' state in ~8-12 cycles and parked, even when the operator wanted a real product. The cause was structural: discovery scoped a tiny v1, the backlog only ever shrank (delete done items, never add), and an empty backlog was hard-wired to mean 'accomplished'. That made Codron collapse toward a one-shot coding agent. 0.8.0 replaces 'empty backlog = done' with a REASSESS gate.
   • · AMBITION tier: you now tell Codron how far to push a project: `prototype` (prove it works, park early for your review), `product` (deepen until a real user would choose it and keep using it), or `service` (product PLUS reliability, edge cases, and regression hardening for a live deployment). Pick it when you create or promote a project, change it anytime in the project's settings tab. The agent reads it every cycle and never raises its own tier; when it thinks a project has earned more, it asks you. Existing projects default to `product`.
   • · REASSESS: when the backlog would empty, the agent stops being a builder and becomes a critic. It re-reads the briefing and plan, then judges the project from MULTIPLE personas (the target users + alternatives from the plan's §2, plus a designer's and operator's eye) against the ambition ceiling: would each of them actually choose this and keep using it, and where's the biggest gap? It picks the single highest-value gap, refills the backlog, and keeps going, or, only at a genuine ceiling, escalates to ask you to raise the tier, or parks with a one-line justification. 'Valuable work' is defined by that yardstick, not a hardcoded checklist, so the work it finds fits the project instead of a template.
   • · 'Accomplished' now means something real. Before, it meant 'my todo list happens to be empty'. Now it means 'I reached the ambition ceiling AND a REASSESS pass found no autonomous high-value work left', and the cycle has to say why (genuinely done, or blocked on something only you can provide: a paid account, a design call, credentials). Raising a parked project's tier in settings re-engages it automatically, so 'this is good, now make it great' is one click.
   • · Validated live: a project that had parked at v1 (empty backlog, accomplished), bumped to the `service` tier, ran one cycle and refilled its backlog with service-grade hardening work it found on its own (graceful handling of bad LLM JSON instead of 500s, URL validation, empty-extraction edge cases, regression tests) and stayed engaged instead of re-parking. Work that genuinely needed the operator (vector-search migration, new input types) was listed separately as gated, not fabricated into busywork.
   • · Feed card meta line leads with cost now (`6.7k · 1:56`, tokens then duration) and drops the relative timestamp; the same engagement's 'when' already shows on its left-panel timeline row, so repeating it in the feed was redundant.
9. v0.7.4Jun 20, 2026Cycle outcome becomes an explicit action the agent picks, not a self-reported confidence float

   • · End-of-cycle `CONFIDENCE: 0.NN` becomes `OUTCOME: clear | verify | halt`. The float was fake precision: LLMs cluster their self-reports in the 0.80-0.95 band regardless of correctness, and the 0.83 vs 0.87 gap carried no real signal, yet the downstream behaviors it drove were only three buckets anyway: proceed to next cycle, request a reviewer cycle, or force a stop. So we now ask the agent to commit to that action directly. `clear` is the silent default. `verify` triggers the reviewer cycle (pair mode only; the prompt doesn't even offer the option when pair is off, so the agent can't pick something that won't run). `halt` replaces the old `< 0.60` forceStuck floor: same hard stop, just driven by an explicit agent decision rather than a heuristic cutoff.
   • · Feed engagement card drops the `conf 0.87` text in favor of a small tinted outcome chip on attention-worthy cycles. `clear` rows stay quiet (no chip: adding one to every row would just be visual noise the eye learns to skip); `verify` is amber, `halt` is red. The eye picks the rows worth a second look out of the strip immediately, instead of decoding a float per row and asking "is 0.78 above or below the cutoff?".
   • · Discovery and reviewer cycles drop the self-assessment line entirely. Their signal was never the number; it was the escalation.json the discovery cycle wrote, or the `.last-review.md` the reviewer cycle produced. Asking those cycles to also pick an OUTCOME would be duplicate plumbing; null in the column is the correct value there.
   • · Telegram cycle-done alerts mirror the dashboard: only `verify` / `halt` cycles surface the chip in the meta line, `clear` cycles stay silent. The bot channel was getting `conf 0.91 / conf 0.88 / conf 0.94` noise every commit; now the rows that earn attention earn a chip and the rest just say `<commit-type> · <sha>`.
   • · The legacy `confidence` column on `engagements` stays in place as a frozen historical column: 0.7.3 and earlier rows keep their floats so existing feeds aren't rewritten, but new cycles write null there and read off the new `outcome` column instead. No data migration; the swap is purely forward-looking.
10. v0.7.3Jun 20, 2026Project view header refresh: 3-col stats grid, aligned tabs, semantic action homes

    • · Left-panel header redesigned. The dot-separated stat line (`11 engagements · 101k tok · 25m 04s`) becomes a 3-column grid, small uppercase label above each value (`ENGAGED / TOKENS / DURATION`), so the lifetime numbers are scannable instead of comma-chained. The duplicate lifecycle chip (`● ACCOMPLISHED`) goes away too: the same chip already lives in the top-bar ProjectSwitcher next to the project name, so repeating it on the left card just read as noise the moment both surfaces landed on screen.
    • · Tab strip aligned with the stats grid. The three tabs render as `grid-cols-3` with the same `px-4 gap-3` as the stats above them, and the tab label is left-aligned within each cell, so `ENGAGED ↕ timeline`, `TOKENS ↕ docs`, `DURATION ↕ source` sit in three crisp columns down the panel head. The active-tab indicator (thin line) tracks the label width via an inline-block wrapper rather than spanning the full cell, keeping the indicator visually tied to the label.
    • · Tab order is `timeline | docs | source` now, with `timeline` as the default landing surface; the live engagement heartbeat is the first thing you see when you open an active project, instead of static docs you'd have to scroll past to find what's happening.
    • · Folder and repo-link icons move from the MissionCard into the Source tab's git header. That's their semantic home (alongside branch / pull / push), and the GitHub icon now always reserves a slot (rendered disabled with a `no git remote configured` tooltip when none is set), so the row's layout doesn't shift as you switch between projects with and without remotes. The Source tab header reads as `[left-side status: branch info / loading / cross-machine / not initialized] [right-side icons]` across every phase, so there's no half-empty strip floating above the body.
    • · `+ add reference` lands inside the Docs tab as the last row of the list, instead of a stranded `+` button in the tab strip. The trigger now sits where the operator is already looking when they reach for it, same pattern as the rest of the docs rows, with `Plus` icon in the tag slot and `add reference` in the filename slot.
    • · Center-panel tabs (`session / feed / preview / api / variables / settings`) get a uniform `min-w-16` so the six labels read as a uniform row instead of jagged box widths driven by label length. Each box stays content-sized rather than stretched to fill, with the active-tab bg highlight unchanged, preserving the full-rectangle hit target.
    • · `fmtCount` (used for the lifetime token counter) extends past M to B. The formatter previously capped at megas, so a project crossing 1B would render as `1234.5M` and overflow the column; it now scales `1.5B` with stable widths at the boundaries (`9.9k → 10k`, `9.9M → 10M`, `999M → 1B`) so the DURATION column to its right never gets pushed.