What's new in Codron

EARLIER · page 5 of 7

1. 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.
2. 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).
3. 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.
4. 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.
5. 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.
6. 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.
7. 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.
8. 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.
9. 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.
10. v0.7.2Jun 20, 2026Scratch becomes a brainstorm surface, decisions take structured answers, and engine installs cascade direct → rescue → docs

    • · Scratch is a read-only brainstorm/research surface now, not a coding sandbox. It used to spawn claude with full Edit/Write/Bash and would happily dive into building something, which then hit the 120s chat timeout and left half-edits behind. Scratch claude now runs with --disallowed-tools=Edit,Write,Bash and a prompt that steers research + recommends promoting to a project when it's time to build; the UI is re-skinned to the session chat's visual language (left-aligned messages, role dots, smooth streaming). A stop button replaces send while a reply streams: clicking it finalizes the pending assistant row, which is also the agent's cancel signal: the in-flight claude process is aborted via an AbortController keyed by the row, and whatever streamed so far stays with a stopped marker.
    • · Decisions take structured per-question answers. When the agent escalates with multiple questions, you used to pick "answer in note" and hand-number your answers in one textarea, eyeballing the question list above. Now the agent emits the questions as structured data and the dashboard renders one input per question, each pre-filled with the agent's researched recommendation, so you edit only what you'd change and the note is assembled for you (one "Q: ... / A: ..." line per question). Telegram also lists the questions so a phone reply can answer them; both surfaces converge on the same final note. Decisions raised before this field existed fall back to the old parse-from-detail path.
    • · Engine connections in Settings learn to actually install everything. Auto-install was npm-only (claude / codex / vercel); every other engine (gh, gcloud, ngrok, supabase, antigravity) just opened a docs link. The new cascade per engine × platform: (1) direct command (`npm i -g …`, `brew install …`, `winget install …`); (2) a claude -p rescue agent that probes which package manager exists on the machine, runs the right one non-interactively, and verifies with `<bin> --version`; handles distro variance and engines with no fixed command (gcloud, antigravity); (3) open the docs URL as the final fallback. Every row shows a single "install" button instead of branching to "install docs", and rescue output streams into the same log panel with a [rescue] prefix.
    • · Docs becomes a tab in the project's left panel. The docs list (briefing / plan / skills / references) used to live inside MissionCard as its own section above the timeline/source tab strip, mixing a section with a tab strip below it. Docs is now the third tab next to timeline and source, and the default tab when you open a project so briefing/plan still land in view. The "+ add reference doc" button collapses to an icon-only "+" on the right of the tab strip, matching the folder/remote shortcuts; a few verbose labels trim down too: "NEEDS YOUR CALL" → "DECISIONS", "REFERENCE DOCS" → "REFERENCES".
    • · Live "engaging…" heartbeat while a cycle is engaged. The event stream goes silent during phases with no tool calls (engine boot, and the final report / decision synthesis at cycle end), so the right-panel log looked frozen and read as "stuck / crashed". An always-animating indicator (staggered pulsing dots, pure CSS) now pins under the event list while the project is engaged, with a centered "engaging…" placeholder filling the pre-first-event gap. Conveys liveness even when no new event has landed.
    • · Fix: preview pane no longer lands blank on tab re-entry. Switching to the preview tab unmounts/remounts PreviewPane, which detaches and re-attaches the WebContentsView. On same-URL re-attach we skip the reload and force a repaint into the new compositor surface via `webContents.invalidate()`, but `addChildView` allocates that surface asynchronously, so a single synchronous invalidate frequently fired before the surface existed and painted nothing. The pane stayed blank until you switched away and back. Now we re-issue invalidate across a few frames (0/50/150/400ms) so at least one lands after the surface is ready; invalidate is idempotent, so the extra calls are cheap no-ops once the frame is painted.
    • · Fix: WebFetch and WebSearch were silently hanging in session and scratch chat. Both chats spawn `claude -p` with `--permission-mode=default`, which gates every tool call on a permission prompt. The spawn has no UI channel to answer that prompt, so any tool outside the implicit cwd-Read allowance silently hung and the model would hallucinate a "permission window" and ask the operator to click Allow. Switched to `bypassPermissions`; the read-only boundary still holds via `--disallowed-tools=Edit,Write,Bash`, so research tools (Read/Grep/Glob/WebFetch/WebSearch/Task) work without prompts and build tools stay blocked.
    • · Variables view auto-masks secret values. Adding a secret-named key (`API_KEY`, `*_TOKEN`, etc.) used to leave it revealed while typing, and saving never re-hid anything you'd toggled open, so a token could sit in plain text on screen until you reloaded. New secret keys start hidden now, and saving re-masks every secret-keyed entry.
    • · Top-bar AGENT chip stops nagging when everything's fine. A bare "AGENT" label + green dot read as orphaned noise; you already know Codron is alive because you're using it. The signal that matters is when the local agent dies and projects stop making progress. Renders nothing while running; the red dot + retry stays in the same slot so the failure case still surfaces in a familiar spot.
    • · Cleanup: removed every em-dash (-) from rendered UI text (empty states, error messages, banners, titles, the variables tab, onboarding copy), replacing them with plain punctuation (period / semicolon / hyphen) that reads the same. Comments, LLM-prompt strings, regex literals, and en-dashes (like "1-3 minutes") are left alone.