v0.16.0 — Measured, and a web client

Four bugs users were hitting on 0.15.5, the provider routing they came out of,
and a graphical client for people who would rather not live in a terminal.

Roadmap note. The 0.15.5 notes put Windows and macOS computer use in 0.16.0
and 0.16.5. That work ran into problems that took longer to sort out than
expected, and the defects fixed below were affecting live runs — so those went
first. Windows and macOS computer use is definitely still coming, in one of the
next few releases. No version number against it this time, given what the last
estimate turned out to be worth.

Fixed — defects that were affecting real runs

• Gemini 2.5 model ids no longer work and were still being shipped. Google
  keeps listing them, but generateContent answers 404 "no longer available to
  new users". A listing is not an entitlement. Anyone who picked Gemini in the
  wizard had a configuration that could not work. Replaced with the 3.x line,
  every id confirmed against a live call rather than a catalogue, and the
  pricing table follows.

• BytePlus and FPT models were being sent to DeepSeek. Both resell other
  vendors' models under their own gateway, so their catalogue ids are bare
  vendor names — deepseek-v4-flash-ga-260813, DeepSeek-V4-Flash. Neither had
  a routing prefix, so choosing one produced an id that routed to DeepSeek's own
  API with a DeepSeek key: wrong endpoint, wrong bill, and an error blaming the
  wrong provider.

• deepseek/deepseek-v4-pro ran against a 128k context instead of its real
  1M. The routing prefix was missing from the strip regex, so the registry
  lookup failed and every caller fell back to a 128k default — compacting about
  eight times earlier than necessary. The bare id was unaffected, which is why
  it stayed hidden.

• The setup wizard told people to retype a valid key. Every connection
  failure offered "re-enter API key". OpenAI answers an unpaid account with 429
  "exceeded your current quota", OpenCode Zen with 401 "Insufficient balance", a
  retired model with 500 — none of which a different key can fix. Failures are
  now classified (auth, billing, rate, model, server, network) and each leads
  with the remedy that can actually help, saying plainly when the key is not the
  problem.

• Pasted text and mouse reports could land in the model picker's filter. A
  paste arrives wrapped in bracketed-paste markers and a mouse report as
  \x1b[<b;x;yM; both decode to keypresses whose text is printable, so their
  bytes were typed into the filter box.

Changed — one provider table instead of five

factory.ts described the same providers five separate times: the strip regex,
the API key resolver, the family resolver, the reverse base-URL map, and a
~320-line chain of construction branches. Nothing forced them to agree, and two
of the bugs above are what that drift looks like from the outside.

There is now one descriptor table, and all five views derive from it. Adding a
provider is a single entry. createProvider drops from ~320 lines to 47.

Two tests hold it together: one asserts the five structures agree with each
other, the other that the user-facing catalogue agrees with routing at all —
every model of all 31 routing targets resolves to its own provider's key.

Added — a web client

aura serve already spoke the full protocol over its WebSocket; what was
missing was a client. React, building to dist/web, served by the same command.

Streaming turns, markdown with copyable code, stop and regenerate, a
conversation sidebar, inline tool calls and approval prompts, a provider picker
across 28 providers with an API-key field when one is missing, tool toggles that
actually reach the engine, live token and cost, dark and light, and a layout
that works on a phone over --lan or --tailscale.

Seven languages — English, Serbian (Cyrillic), French, Italian, Spanish, Arabic,
Russian — with Arabic driving real right-to-left through logical properties
rather than a transform.

The design mirrors the TUI: every colour is taken from the terminal palette.

Commands beginning with : run rather than reaching the model. Fourteen work in
the client; the rest are reported by name as terminal-only rather than silently
sent to the agent as a question.

Security

• Plugin install, plugin removal and API-key changes are off by default.
  aura serve exposed them to anything holding the pairing token. Installing a
  plugin downloads and runs code with the server's full privileges and no
  sandbox, so under --lan or --tailscale that turned any paired device into
  remote code execution. All three now require aura serve --allow-plugin-install; listing what is installed stays open.
• A proven pairing token becomes an httpOnly; SameSite=Strict cookie, so
  the page's own asset requests authenticate. Without it every subresource 401'd
  and the page rendered blank.
• Model output is sanitised before rendering. The client renders markdown as
  HTML, and on the agent path that output carries whatever a tool read off disk.
  Raw HTML is disabled at the renderer and the result is scrubbed anyway, tested
  against the actual vectors.

Added — measurement

• The escalation benchmark had never run. It was excluded from npm test
  correctly, being slow and live, but pinned to an account that later lapsed —
  so it self-skipped, and a benchmark that skips is indistinguishable from one
  that passes. First live result: 6.7% missed escalation, 0% false
  escalation over 30 cases. Both misses are design-mode; retrieval was 15/15.
• A Gazelle blind eval, because 26x fewer tokens was a cost measurement with
  no quality number beside it. Blind-scored, labels stripped: 114x fewer
  tokens, correctness a wash on conversational prompts and +2.89 on
  questions needing tools, where the coder path ran out of room and answered
  anyway. The judge saturated on helpfulness, so that half is reported as
  unmeasured rather than as a result.
• The cost ledger no longer counts an unbilled call as a measured zero. A
  provider error or an exhausted balance is not evidence that the large model
  would have cost nothing, and counting it that way reported the gate as a total
  loss.
• Recorded provider fixtures, one per wire format rather than one per
  vendor: there are four formats behind thirty-one routing targets.

Also

• The verifier can run on a separate provider, so it stops marking its own
  homework.
• It now sees the evidence an answer is actually about — identifiers, paths,
  line refs — rather than a flat 300-character head of each tool result, which
  on a real file read was about 6% of the evidence, chosen without reference to
  what was being checked.
• A second training path writes direct correction pairs from escalation
  episodes; every row carries its provenance so the two sources can be ablated
  separately. Neither path runs automatically.
• docs/SANDBOX-DESIGN.md — a design for --sandboxed, a real out-of-process
  boundary, with the mechanism verified but not yet implemented. The default
  path remains a guardrail, and SECURITY.md still says so.

v0.15.5 — Computer Use on Linux

Computer use, on Linux. The agent can see the screen and drive the real pointer
and keyboard — and the same release closes four instances of one recurring
defect: an operation that reports success while doing nothing. Windows and
macOS follow in 0.16.0 and 0.16.5.

This section also carries the work tagged as 0.15.0 on 2026-08-19, which never
reached GitHub or npm; folding it in here rather than shipping a version nobody
could install.

Added — computer use (Linux)

• The computer tool. Actions: screenshot, click, double_click,
  right_click, move, drag, type, key, scroll, remember. The model
  always speaks the coordinates of the image it was shown; captures are
  downscaled before sending, and conversion happens once on the way to the input
  device. Asking the model to scale its own coordinates is asking it to do
  arithmetic it cannot check, and being wrong looks like a misgrounded click.
  There is no automatic screenshot after each action — it would double the token
  cost of a run, and most sequences (type, key, key) need no visual
  confirmation; the replies tell the model to verify instead.
• A Python sidecar for capture and input (src/tools/screen/aura_screen.py),
  one long-lived process per run. Both halves hold state a one-shot call cannot:
  the ScreenCast portal session dies with its D-Bus connection, and the uinput
  device disappears when its descriptor closes. On KDE Plasma 6 Wayland this is
  the only stack that works — xdotool cannot see Wayland, ydotool 1.0.4
  creates a relative-only device, and the RemoteDesktop portal's absolute
  pointer motion is ignored. All three accept the call and silently do nothing.
• Disclosure and a two-key opt-in gate. Both --computer and
  AURA_COMPUTER_USE=1 are required, deliberately independent of the permission
  level: auto approves everything but run_shell, and its blocklist is regex
  over shell strings — it cannot inspect a click at (x, y) even in principle.
  The disclosure states plainly that a screenshot is the whole desktop, not the
  project, and that a misgrounded click lands on whatever is really there.
  Acknowledgement is stored beside the global config, so a wizard rewrite cannot
  clear a consent decision.
• A computer section in doctor. Every dependency the sidecar needs is
  present on a machine already using the feature and absent on a fresh one, so
  without a preflight the first symptom is a task dying mid-run with a Python
  traceback, after the model has spent turns planning around a tool that could
  never work. Reported as warn, never error — a machine that will never enable
  computer use is not broken for lacking evdev.
• Images in tool results, which is what lets a screenshot reach the model at
  all.

Added — publishing: HTML to PDF and PNG

• design/render.ts and the document tool. Aura could already write
  strong HTML, but everything downstream of it was missing or pretended: PDF
  generation existed only as a sentence in a prompt, and page.pdf() was called
  nowhere. HTML is the authoring format; PDF and PNG are render targets.
  Built around the two failures that produce a file which looks fine and is
  wrong — a webfont whose file arrived but was never applied (a document
  perfectly set in Times), and a page that threw yet still printed, as empty
  pages a page count cannot distinguish from a real document. Both are now
  reported unprompted.
• Print-first templates (design/templates/) as stylesheets rather than
  string substitution, so design routing stays meaningful. They cover the
  defects invisible until someone prints: dropped backgrounds, stranded
  headings, split table rows, and the trailing blank page decks leave behind.
• util/chrome.ts, ending a duplication that had already diverged with each
  copy holding half the answer — one resolved symlinks but had no direct-path
  fallback, the other had fallbacks but returned the unresolved path.

Added — search backend enablement

• Real search backends. web-search.ts rewritten to back the search tool
  with Tavily and Brave (API-backed) plus DuckDuckGo (HTML extraction with
  challenge detection) and a liveness probe; the bootstrapAuraEnv step now
  activates these backends at startup. Includes tests/web-search.test.ts.

Added — designx

• designx design commission command. A 14-direction style lexicon with
  per-target risk 1–5 and fits/cues, risk-banded routing
  (classic 1–2, balanced 1–4, wild 3–5, feral 4–5), seeded deterministic routing
  (mulberry32 + FNV-1a seedFrom), and artefact-based success. Run via
  :designx [web|deck|pdf] <brief> [--wild|--classic|--style <id>] [--seed <n>],
  with :designx styles listing the lexicon.

Added — providers

• fpt/ routes to the FPT Cloud AI marketplace. README and
  agents.env.example documented the prefix before any code implemented it, so
  -m fpt/DeepSeek-V3 fell through to the generic OpenAI-compatible branch and
  sent an FPT model id to OpenAI with an OpenAI key. FPT_BASE_URL is honoured
  for per-account endpoints, and the model id keeps its case because marketplace
  ids are mixed case and the gateway matches them exactly.

Fixed — operations that reported success while doing nothing

• read_file extracts PDF text. A résumé came back as
  Binary file: DM_Resume.pdf (254.7 KB) because .pdf sat in
  BINARY_EXTENSIONS beside .zip and .exe. At the byte level a PDF is
  binary, which is why it reads naturally in that list — but .zip is opaque
  bytes and a PDF is a container with a text layer. Nobody noticed because it
  never threw: a refusal wearing the costume of a result, so the model worked
  around it, and sharper models found pdftotext on their own. Uses -layout,
  verified against a two-column CV where raw extraction order interleaves the
  sidebar into the body. A scanned PDF with no text layer says so and points at
  OCR rather than returning a convincing empty string.
• AURA_MAX_TOKENS budget fix. openai-compatible.ts now resolves
  maxTokens from the environment before falling back to the 16k default,
  fixing finish_reason: "length" truncation when a provider's ceiling was
  larger than the hardcoded budget.
• .gitignore: .env!.example was a typo for !.env.example, so the
  negation never applied.

Documentation

• .env.example names Brave and Tavily as search backends that actually work,
  since DuckDuckGo bot-checks many IPs, and documents the two ceilings that
  truncate long single-file output with symptoms that point nowhere near their
  cause: AURA_MAX_TOKENS (reasoning models spend the output budget on internal
  thinking before emitting anything) and AURA_STREAM_IDLE_MS (the same models
  pause longer than the 60s idle timeout between thinking and emitting).
• README documents :designx and the FPT provider.

Notes

• Computer use is Linux only in this release.
• src/util/rtk.ts remains uncommitted (+53) with
  tests/rtk-wrap.test.ts (+79), still out of scope pending separate review.
  The rtkWrap rewrite touches every model-authored command the Telegram bot
  executes.

v0.14.0 — Claim-Type-Aware Verification + Design Council

Added

• Claim-type-aware verification. The Archimedes verification gate now distinguishes
  retrieval tasks (strict tool-evidence corroboration) from design tasks (factual
  premises still strict, novel proposals judged on coherence/relevance). This fixes
  a structural bias where good designs were penalized for lacking tool evidence.

• Design council escalation. When a design task fails large-model verification,
  it can escalate to a 5-agent design council that generates divergent solution
  proposals with tradeoffs, then synthesizes them into a structured recommendation.
  Council only fires when large-model verification fails AND the session budget allows
  the estimated 80k token cost.

• SessionBudget integration into ArchimedesAlternator. The alternator now
  respects the session token budget, checking before council escalation and
  skipping with a warning if the budget would be exceeded.

Changed

• runCouncil() in src/research/council.ts now accepts a mode parameter
  ('research' | 'design') to switch between convergent truth-finding and
  divergent solution generation prompts.

• AlternatorOptions interface now includes optional sessionBudget parameter
  for cost control during council escalation.

Fixed

• Fabrication regression guard. The original fabrication case (answer describes
  a nonexistent function that search_code returned nothing for) is still caught
  as INVALID after the design-aware verification changes. Factual premises in
  design tasks remain strictly verified — fabrication-under-cover-of-proposal is
  explicitly prevented.

v0.13.5 — REPL Mode Switch Restored

Versions step by 0.0.5 from here on: 0.13.5, 0.14.0, 0.14.5, and so on.

Added

• :gazelle and :coder work in the ordinary REPL again. Restored
  unchanged from v0.13.1, which was withdrawn on suspicion of causing a task to
  loop on one step. It wasn't: 0.13.0 traced that to step-3.5-flash collapsing
  into repetition inside a single streamed reply, with nothing in the harness to
  stop it. The mode branch never ran in coder mode — it was inert while
  replMode === 'coder', and the coder path beneath it was untouched — so with
  the real cause fixed there is nothing left to hold it back.

  :help and the README have advertised both commands since Gazelle landed,
  while only the --gazelle orchestrator implemented them; typed into the plain
  REPL they fell through the command handler and were sent to the model as a
  task. Now the TUI switches in place: the machinery of a Gazelle turn lives in
  agent/gazelle-chat.ts, independent of how input arrives, so the TUI can drive
  it without opening a second readline on stdin it already holds in raw mode
  (two readers on one stream double every keypress). Lean turns share the REPL's
  conversation — carried both ways, coder tool noise stripped on the way in —
  count against the session token ceiling, and appear in /stats; the status
  line gains a gazelle marker. A mode switch or second message arriving while a
  reply is still streaming waits for it rather than interleaving two
  conversations into one history.

  The commands live in cli/repl-mode-commands.ts because nothing in
  cli/index.ts can be imported by a test, which is how a command stayed
  advertised and unimplemented without anything going red. One of the tests walks
  :help's Modes section and asserts every command it lists is handled.

v0.13.0 — Repetition Guard + RTK Token Optimization

Carries the RTK token work from 0.12.9 plus the fix below. Briefly tagged
v0.12.10 before being renumbered; same content, no npm release under that
number.

Fixed

• A reply that collapses into repeating one phrase is now cut off, not paid
  for to the last token. stepfun/step-3.5-flash, asked to build a large HTML
  page, narrated Writing the HTML structure... several hundred times, spent
  its entire 16,384-token output allowance, returned stopReason: 'limit', and
  the run ended having written nothing. It reproduced on every attempt in the
  session. Nothing in the harness noticed: text chunks were appended and printed
  regardless of what they contained, and the only backstop was the model's own
  output cap.

  agent/repetition-guard.ts watches the stream's tail for an exactly periodic
  cycle — which is what a collapsed model emits, and what ordinary prose never
  does — and trips after ~1,200 characters of it. The loop then:

  • stops reading, which returns the generator and aborts the HTTP request,
    so the provider stops generating (and billing) the remaining output. The
    openai-compatible adapter had no cleanup on early exit; it now aborts its
    controller in a finally unless the stream drained normally;
  • keeps the loop out of history — only the text from before the collapse
    survives, plus a one-line marker. A model shown even a few copies of its own
    loop carries on with it, which is why every later turn in that session
    repeated too;
  • retries with the failure named, telling the model to make the
    write_file call it was narrating instead of describing it. Twice, then it
    gives up and says plainly that this is a model failure and suggests a
    stronger --model, rather than implying the task was at fault.

  AURA_REPETITION_GUARD=0 disables it. The thresholds are set so ordinary
  output cannot reach them, but nobody should have to wait for a release to
  switch off something that truncates replies.

  Two compaction fixtures used 'y'.repeat(10_000) as filler and now trip the
  guard on purpose — a model emitting ten thousand identical characters is
  exactly this bug. They use varied prose of the same length instead; the token
  volume they depend on is unchanged.

v0.12.9 — RTK Token Optimization (−80%)

Supersedes v0.13.1, which was tagged earlier the same day and withdrawn —
see "Reverted" below. This release is v0.13.1 minus the REPL mode switch: the
RTK token work and the Telegram search verb, nothing else.

Reverted

• :gazelle / :coder in the plain REPL is withdrawn. Shipped in v0.13.1;
  pulled after a coder-mode task looped on one step ("Writing the HTML
  structure…" repeated until it hit the token ceiling, ending after 7 turns).
  The mode branch is inert while replMode === 'coder' and the coder path was
  unchanged beneath it, so the loop is probably not from this — but a release is
  not the place to find out. :coder and :gazelle again work only inside a
  session started with --gazelle; in the plain REPL they are unhandled and get
  sent to the model as a task, as before. Under investigation; RTK's compression
  of run_shell output is the first suspect, since a model that cannot see
  whether a write landed will retry it.

Changed

• Shell and git tool output now goes through RTK — 80% fewer input tokens per
  session. RTK was installed on the machine, but its Claude hook only rewrites
  commands typed at a terminal. Aura's own tools shell out through Node's
  exec/execSync directly, so run_shell, the git tool, and the Telegram
  bot's execShell bypassed the proxy entirely: raw git diff, git log and
  grep output landed in the context window uncompressed, and the bloat
  compounded as a session grew. Each of those call sites now prefixes rtk
  (skipped when the command already starts with it), and gitStatus/gitDiff
  invoke rtk git … explicitly.

  Measured over the same three tasks — an uncommitted-changes review, a
  TypeScript compiler-API audit, and a changelog web page build — run four times
  as the patches went in:

  Run	State	Input tokens	Turns	Tool calls
  1	no RTK (raw node exec)	1,286,806	40	60
  2	telegram-bot.ts patched	946,293	39	70
  3	tools.ts patched	397,519	16	28
  4	fully optimized	253,039	13	23

  80.3% fewer input tokens and 67.5% fewer turns for identical work. Compressed
  summaries don't just cost less than raw terminal noise — the model converges
  faster on them. Full write-up in rtk-optimization-report.md.

  RTK stays optional. Prefixing unconditionally would have made it a hard
  runtime dependency of a published package — every run_shell call on a machine
  without it returning "rtk: command not found". util/rtk.ts probes PATH once
  per process (a filesystem scan, no which subprocess) and passes the bare
  command through when RTK isn't there. AURA_RTK=0 forces the raw command even
  when it is installed, which is what you want when checking exactly what a tool
  ran; AURA_RTK=1 skips the probe.

Added

• SEARCH: for the Telegram bot. The bot could run shell commands, send
  files and take webcam stills, but had no way to look anything up — so it
  answered questions about current events from stale weights, or claimed it
  could not search at all. SEARCH: <query> now hits DuckDuckGo's lite HTML
  endpoint (no API key, no SDK) and returns the top five titles, URLs and
  snippets. The action prompt tells the agent to reach for it first when it
  lacks up-to-date information, and the "never claim you cannot…" instruction
  now covers searching alongside sending and photographing.

v0.12.2 — REPL Token Ceiling + TUI Scroll-Mode Fixes

Added

• Cumulative token ceiling now covers the plain REPL session. Previously
  only the gazelle orchestrator's coder-conversation path held a
  SessionBudget; the REPL passed none, so recordTurn/recordCall were
  no-ops and net-of-cache spend was never tracked across messages. One budget
  now lives for the life of the REPL process.

  Turn-count enforcement is deliberately not extended here. The
  per-invocation maxTurns guard already holds correctly in the REPL, and a
  cumulative turn cap is the wrong instrument for interactive use where a
  human types every message and watches every response. Measured on a real
  96-minute session — 58 turns across 9 messages, 86% cache hit rate, $0.50
  total, peak 19 turns in any single message — a 50-turn session cap would
  have interrupted that for crossing a count that said nothing about its cost.

Fixed

• TUI: SS3-encoded arrow keys corrupted the input and flipped the screen.
  Terminals in application-cursor mode send \x1bOA for Up. The input parser
  handled CSI (\x1b[A) but not SS3, so the sequence fell through to the
  bare-Escape branch: Escape entered scroll mode and the remaining O and
  final letter were typed into the input as literal text. Pressing an arrow
  key could flip the display to the scroll view and inject garbage.

  This is very likely the real cause of the "response stalled, then typing
  fixed it" reports — the live view was frozen in scroll mode, not the network
  connection. Typing a printable character exits scroll mode and redraws,
  which is exactly the observed "fix". Normalized the same way
  context-tuner.ts's splitKeys already did, including waiting for the
  final byte when the sequence is split across reads.

• TUI: typing q to leave scroll mode silently dropped the character — a
  word beginning with "q" lost its first letter. q was excluded from the
  printable-exit path but advertised nowhere. i remains excluded on purpose:
  the scroll indicator documents "i/Enter/Esc insert", so it is a deliberate
  vim-style command.

• TUI: terminal resizes during an overlay were dropped entirely. While a
  command palette, session switcher, context tuner, or confirmation prompt
  held the screen, handleResize returned early and the event was lost,
  leaving the scroll region set to the old geometry once the overlay closed.
  The resize is now recorded and applied when input resumes.

Known follow-ups (not in this release)

• ESC timeout. A lone Escape stays buffered until the next byte arrives,
  so pressing Esc alone does nothing until another key is pressed. Fixing it
  needs a ~25–50 ms timer to disambiguate Escape from the start of a sequence;
  a fixed timeout can misfire on slow terminals and high-latency SSH, so it is
  deferred to its own pass rather than rushed into a patch release.
• Archimedes alternator has no budget wired in at all. alternator.run()
  accepts no budget in its options interface, so neither ceiling applies to
  that path. Closing it needs a signature change.

Fixed (previously unreleased)

• npm test sent a real Telegram voice message and overwrote a real API
  key. Two tests reached outside their sandbox on any machine with a
  configured bot:

  tests/telegram-voice-live.test.ts was gated skipIf(isCI || !hasTelegramConfig)
  — it skipped on CI and ran everywhere else, firing a live voice note at
  telegram.json:default_chat_id on every run. The sends left no trace in the
  bot's journal or session history (they came from the vitest process, not the
  bot service), which made them look like unexplained "the bot keeps sending me
  audio every few hours" behaviour. Now opt-in via AURA_LIVE_VOICE_TEST=1,
  and it requires an explicit AURA_TEST_CHAT_ID rather than falling back to a
  real person's chat.

  tests/provider-wizard.test.ts isolated XDG_CONFIG_HOME but not
  os.homedir(), which is what key-store.ts uses — so saveKey() wrote the
  fixture sk-test-key into the developer's real ~/.aura/keys.json,
  replacing their DeepSeek credential. It now mocks os.homedir() like the
  other filesystem-touching tests.

• Streaming responses could hang forever on cloud providers. An SSE stream
  can go silent without the TCP connection closing — no error, no terminating
  chunk, the read simply blocks on data that never arrives. Aura waited
  indefinitely and showed the user nothing.

  The SDKs do not cover this, despite appearing to. Both openai and
  @anthropic-ai/sdk default to a 600s timeout, but implement it as
  fetch(...).finally(() => clearTimeout(timer)) — and the fetch promise
  settles when response headers arrive, which for a stream is immediate. The
  timer is cancelled before a single chunk of the body is read, so the
  documented timeout covers time-to-headers and nothing else.

  Streams are now guarded by an idle timeout measured between chunks
  (src/providers/stream-timeout.ts), default 60s, applied to both the
  OpenAI-compatible and Anthropic paths. Total-duration limits would be the
  wrong tool: a legitimate turn can run for minutes through tool calls, but a
  healthy stream never goes quiet for long once tokens flow. 60s was calibrated
  against 529 consecutive-turn intervals from this project's own token log
  (median 3.9s, p90 27s — and those measure whole turns including tool
  execution, so real inter-chunk gaps are far smaller).

  On a stall the underlying request is aborted, so the socket is released
  rather than leaked. The request is retried once, but only when nothing has
  reached the consumer yet — after text has been yielded the agent loop has
  already accumulated and displayed it, and re-running would append a second
  full response, corrupting both the transcript and the token accounting. In
  that case the stall surfaces as a clear provider error instead of hanging.
  This mirrors the existing rule in resilient.ts, which retries acquisition
  of the first chunk but never a mid-stream failure.

  Override with AURA_STREAM_IDLE_MS (values below 5000 are floored; 0
  disables the guard entirely).

v0.12.1 — Capped Threshold Readout in /context tune

Highlights in v0.12.1

Patch release over v0.12.0.

• /context tune now reports the threshold compaction actually uses. The tuner showed each rung as a plain share of the context window, ignoring the absolute context.maxTokens cap. On a 1M-window model it claimed compaction fires at 550.0k while the engine fired at the 80k cap — so on exactly the models the cap was introduced for, the tuner was reporting a number nothing in the system used.
• Rungs held at the cap are marked, and a fully inert ladder says so. Previously, moving a rung that sat entirely above the cap changed the display but could not change behaviour, with nothing on screen explaining why.
• /ct — short alias for /context tune, in :help and the README.

Before:

  ◆ Context: ████░░░░░░░┊░░┊░░┊░░ 21% (210.0k/1000k)
                        ▲  rung 1/3: 55% (550.0k)

After:

  ◆ Context: ████░░░░░░░┊░░┊░░┊░░ 21% (210.0k/1000k)
                        ▲  rung 1/3: 55% (80.0k — capped)
  ladder: 55% → 70% → 85%
  ladder inert: every rung is above the 80k cap — raise context.maxTokens

The bar geometry is unchanged — rungs still plot at their window share, keeping the tuner consistent with the context footer.

Full detail in CHANGELOG.md.

npm install -g aura-code@0.12.1

v0.12.0 — Context/Cost Controls

release: v0.12.0 — context/cost controls, kanban removal

See CHANGELOG.md. Session-level turn/token budget replaces the previous
per-segment turn cap; compaction threshold gains an absolute cap so it binds
on large-window models; cache accounting fixed for OpenAI-compatible
providers; GLM pricing corrected against published rates; reasoning-model
content handling fixed for local models via Ollama's OpenAI-compatible
endpoint.

Removals (src/kanban, archimedes fine-tune/training-data,
anthropic-oauth-draft) were dead code with no call sites — see 3560c77.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

v0.11.0 — Gazelle Conversational Mode & Telegram Fix

Highlights in v0.11.0

• Gazelle Conversational Mode (Phases 1-3): Lean conversational path alongside the coding agent skipping ProjectContext, tool schemas, Archimedes, and verification gate for fast response times and ~128x token savings.
• Session-end Conversational Memory: Automatic concise session summaries and context persistence across sessions.
• Telegram Service Fix: Resolved service initialization and listener behavior.