aegis-desktop 0.8.32 → 0.8.34

package/main.js

@@ -1748,6 +1748,18 @@ function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished,
     if (name === 'chat') {
       ipcMain.handle(`${MODEL_PREFIX}${name}`, (event, payload) => {
         const opts = { ...(payload || {}) };
+        // The rung every renderer sends is low|medium|high; this is the one
+        // place a stale window can still hand us the retired `auto` (a page
+        // loaded before the select lost that row, or a renderer that forgot to
+        // resolve), and a falsy effort is NOT "the engine's default" — the
+        // shared engine states the field conditionally, so an absent value
+        // means "state no opinion" and the server sizes the turn itself. So it
+        // is normalised here rather than passed through: an unknown value
+        // becomes `high`, the same floor the engine and the CLI apply, and no
+        // turn can reach the wire with an effort nobody chose.
+        const effortRung =
+          opts.effort === 'low' || opts.effort === 'medium' ? opts.effort : 'high';
+        opts.effort = effortRung;
         const sender = event && event.sender;
         const forward = (chunk) => {
           if (

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.8.32",
+  "version": "0.8.34",
   "description": "Thin Electron host for AEGIS — a local chat UI over the shared client/aegis.js transport. Ships transport + UI only; engine logic stays server-side.",
   "author": {
     "name": "AEGIS Code",

package/renderer/app.js

@@ -490,6 +490,22 @@ function rollFor(sessionId) {
  * per-turn figure beside the session total (the CLI shows both: the meta row's
  * `1.5k tok` and the status bar's rolling total).
  */
+/**
+ * The account's entitlement snapshot, as the main process last reported it.
+ *
+ * One reader for the money rule, so the rows that print a charge cannot disagree
+ * with each other about which tier they are on — `feeWaived` in usage.js holds
+ * the rule itself. `state` is read defensively because this runs on paths that
+ * can fire before the first entitlement probe has answered: with no snapshot yet
+ * there is no proven tier, and `feeWaived(null)` says "not waived", which is the
+ * only safe reading of an unproven account (it is the same reason
+ * `entitlement.js` starts at the free boundary rather than at Pro).
+ */
+function entitlement() {
+  const s = typeof state !== 'undefined' ? state : null;
+  return s && s.entitlement ? s.entitlement : null;
+}
+
 function foldRoll(sessionId, usage, opts = {}) {
   const id = sessionId || '';
   const next = rollTurn(rollFor(id), usage, opts);
@@ -500,7 +516,7 @@ function foldRoll(sessionId, usage, opts = {}) {
 
 /**
  * Paint the topbar meter. Hidden while a session has accounted for nothing —
- * an unused thread must not display a `0 tok` it never measured — and shown
+ * an unused thread must not display a `0 tokens` it never measured — and shown
  * the moment a turn is folded in.
  *
  * `live`, when given, previews the in-flight turn on top of the session's
@@ -517,6 +533,23 @@ function foldRoll(sessionId, usage, opts = {}) {
  */
 function renderRollMeter(sessionId, live) {
   const el = els.sessionMeter;
+
+  // The bubble's live figure is painted FIRST, before any of the topbar's own
+  // gates can return early. It belongs to the turn in flight — it is the thing
+  // the reader is watching while the AI works — and it used to sit at the
+  // BOTTOM of this function, behind `if (currentSessionId !== sessionId)
+  // return` and behind `if (!el) return`. So a turn whose sessionId did not
+  // match the current view, or any window where the topbar element was
+  // missing, streamed to completion with a dead counter in the bubble even
+  // though the estimate was being recomputed here every frame. That is the
+  // "tokens don't work while the AI is working" report.
+  const liveCount = live ? liveTokenFig(live) : '';
+  const tokensEl = live ? liveTokensEl() : null;
+  if (tokensEl) {
+    tokensEl.textContent = liveCount;
+    tokensEl.hidden = !liveCount;
+  }
+
   if (!el) return;
   if (currentSessionId !== sessionId) { el.hidden = true; return; }
   let roll = rollsBySession.get(sessionId || '');
@@ -534,7 +567,115 @@ function renderRollMeter(sessionId, live) {
   const line = roll ? fmtRoll(roll) : '';
   el.textContent = line;
   el.hidden = !line;
+  // A live figure is an estimate of a turn still in flight; the class is what
+  // says so, so a reader is never left comparing a moving number with a settled
+  // one and concluding the meter lies.
+  el.classList.toggle('live', !!live && !!line);
   if (line) el.title = 'This session, counted the way the CLI counts it — every turn rolled into one running total';
+  return roll;
+}
+
+/**
+ * The bubble's live figure — `↓N tokens`, the CLI's live spinner tail — for a
+ * turn still in flight, or '' when there is nothing measured yet.
+ *
+ * OUTPUT only (the answer plus the thinking trace it was billed with), never
+ * input + output: this figure has to be the same quantity the CLI's spinner
+ * reports (`cli/src/chatflow.js`: `↓${fmtTokens(state.streamed)} tokens`, fed
+ * `streamedCells() / 4`) and the same one aegiscodex-dev climbs with while it
+ * works. Adding the prompt in made this surface count a second, much larger
+ * quantity that opened high and barely moved.
+ *
+ * Two ways to fail closed on the same number, because a dead counter is worse
+ * than a roughly right one — it tells the reader the turn has stalled:
+ *
+ *   1. `estimatedBuckets` is the authority. If it is unavailable or its shape
+ *      is not what this call site expects, the throw used to escape into the
+ *      painter every frame, so the figure never appeared at all while the
+ *      answer streamed normally beside it. Caught.
+ *   2. Below that, the estimate is taken from the stream itself — the reply's
+ *      own text at the 4:1 chars:tokens ratio of the same heuristic, i.e. the
+ *      quantity the CLI's tail is built on. So there is a number to show from
+ *      the first chunk regardless of what the model reports or bills.
+ */
+function liveTokenFig(live) {
+  const reply = typeof live.reply === 'string' ? live.reply : '';
+  const reasoning = typeof live.reasoning === 'string' ? live.reasoning : '';
+  // A turn in flight that has produced nothing YET. Its figure is zero, and
+  // zero is what the other measured surface shows at this moment: the CLI's
+  // spinner tail counts the answer's deltas and the thinking trace's, so it too
+  // reads `↓0 tokens` only until the turn's first billed token.
+  //
+  // This is the ONE place the figure deliberately differs from the reference
+  // engine's, and the difference is the source of the number rather than its
+  // format: `aegiscodex-dev/src/main.js` climbs on ELAPSED TIME
+  // (`Math.round(secs * 21 + 7)` with `secs = Math.max(1, …)`, so its floor is
+  // 28 and it never prints 0) while this host reports what the turn actually
+  // produced. Matching the reference frame-for-frame would mean printing a
+  // count no provider ever sent, which this repo refuses everywhere else
+  // (`fmtRoll` will not put `0 tokens` on a meter that never took a reading;
+  // `fmtUsageSplit` omits an unmeasured half rather than inventing one). The
+  // measured zero is honest and self-correcting within the first token.
+  //
+  // Returning '' here was the start-of-turn lag — the bubble opened with no
+  // figure at all and popped one in seconds later, once the reply had grown past
+  // a threshold. Safe because the caller only passes `live` for a turn still
+  // running: this is a statement about that turn, not a fabricated measurement
+  // of a finished one.
+  if (!reply && !reasoning) return '↓0 tokens';
+  let output = 0;
+  try {
+    const est = estimatedBuckets(live.prompt, reply, reasoning);
+    if (est && typeof est.output === 'number' && est.output > 0) output = est.output;
+  } catch (err) {
+    /* the stream-text estimate below is the whole point of the fallback */
+  }
+  if (!output) {
+    // Counted, never spread. `[...part].length` is the readable spelling of
+    // "how many codepoints", and it is the one this fallback started with — but
+    // this function runs inside the painter, so on every frame of every turn
+    // that takes this path it built a full codepoint array of the whole reply
+    // and threw it away: 100k entries per frame, ~60 frames a second, on the
+    // largest replies. The codepoint walk below yields the identical count
+    // without the array (a surrogate pair is one codepoint, two UTF-16 units),
+    // so the figure is unchanged and the per-frame allocation is gone.
+    let cells = 0;
+    for (const part of [reply, reasoning]) {
+      let i = 0;
+      while (i < part.length) {
+        const cp = part.codePointAt(i);
+        i += cp > 0xffff ? 2 : 1;
+        cells += 1;
+      }
+    }
+    output = Math.ceil(cells / 4);
+  }
+  if (!output) return '';
+  return `↓${Math.round(output)} tokens`;
+}
+
+/**
+ * The live figure's element, CREATED ON DEMAND when the row does not have one.
+ *
+ * `setBusy` appends it, but not every working row goes through `setBusy`: a
+ * turn opened by `ensurePendingRow` (tool activity arriving before any text)
+ * had no `.typing-tokens` to find, so the meter had nowhere to paint. Built
+ * here, a sibling of `.body` for the same reason as there — `paintStream`
+ * assigns the body's `textContent` wholesale and would delete a child.
+ *
+ * Painted by `renderRollMeter`, the same authority that writes the topbar
+ * meter, so the two can never disagree.
+ */
+function liveTokensEl() {
+  if (!pendingEl) return null;
+  let el = pendingEl.querySelector('.typing-tokens');
+  if (!el) {
+    el = document.createElement('span');
+    el.className = 'typing-tokens';
+    el.hidden = true;
+    pendingEl.appendChild(el);
+  }
+  return el;
 }
 
 /**
@@ -833,8 +974,8 @@ function currentBudgetModel() {
  */
 function budgetNote(cls, model) {
   const chosen = effortFor();
-  const rung = chosen || 'high';
-  const rungText = chosen || 'auto → high';
+  const rung = chosen;
+  const rungText = chosen;
   if (cls === AUTONOMOUS_CLASS) {
     // aegis1 services/pool_brain.py pass_budgets — the total across the worker
     // fan-out + synthesis pass, which is why it is not the local table.
@@ -864,16 +1005,20 @@ function updateBudgetControls(cls, model) {
 }
 
 /**
- * The effort to send, or undefined for "no rung pinned".
+ * The effort rung to send: always 'low' | 'medium' | 'high'.
  *
- * Sent for EVERY class and model, not just the pooled one: with no max-tokens
- * control there is nothing else that sizes a call, and `auto` means "no rung
- * pinned" — the engine's high default — rather than the old silent
- * fall-through to the top rung.
+ * Sent for EVERY class and model. The three-rung select has no "auto" row any
+ * more, because "no rung pinned" is not a fourth level — it was the DEFAULT,
+ * so a fresh window sent no effort at all and every model ran on whatever the
+ * far end happened to do, which is what "the levels do nothing" was.
+ *
+ * A missing select (or one holding a stale `auto` persisted before this
+ * change) resolves to `high`, the same default the engine and the CLI apply,
+ * so an unreadable control can never silently mean "smallest".
  */
 function effortFor() {
   const value = els.effortSelect && els.effortSelect.value;
-  return value && value !== 'auto' ? value : undefined;
+  return value === 'low' || value === 'medium' ? value : 'high';
 }
 
 // ---------------------------------------------------------------- UI helpers
@@ -2121,7 +2266,7 @@ function memoryCard(e) {
   if (rel) bits.push(rel);
   else if (e.timestamp) bits.push(e.timestamp);
   if (e.session) bits.push(`session ${e.session}`);
-  if (e.tokenCount != null) bits.push(`${e.tokenCount} tok`);
+  if (e.tokenCount != null) bits.push(`${e.tokenCount} tokens`);
   meta.textContent = bits.join(' · ');
   head.appendChild(meta);
   li.appendChild(head);
@@ -3042,10 +3187,15 @@ async function spawnPath(card, spec) {
     // A lane card is a dispatch the same way a turn is, and it was the
     // un-costed half of the 3x story: it reported tokens with no charge beside
     // them, so the extra calls were the least visible thing on the screen.
+    // The card is also the place the wire's TOTAL was most misleading: a lane
+    // re-sends the request plus a path hint, so its input half is nearly the
+    // whole count and the card read as though the path had produced it all.
+    // The figure is the output, like every other per-dispatch surface here.
     const flow = turnAccounting(data && data.usage, spec.model, {
       costUsd: data && typeof data.costUsd === 'number' ? data.costUsd : undefined,
     });
-    if (flow.tokens != null) bits.push(`${flow.tokens} tokens`);
+    const flowProduced = displayTokens(flow);
+    if (flowProduced != null) bits.push(`${flowProduced} tokens`);
     if (flow.cost != null) bits.push(fmtCost(flow.cost, flow.real));
     // …and roll it into the session, which is the half that was missing. The
     // card shows this ONE dispatch; a session total that skipped it would be
@@ -3164,6 +3314,19 @@ function setBusy(busy, { cancellable } = {}) {
     dots.className = 'typing-dots';
     for (let i = 0; i < 3; i++) dots.appendChild(document.createElement('span'));
     pendingEl.querySelector('.body').appendChild(dots);
+    // The live token figure, rendered by `renderRollMeter` — the same authority
+    // that writes the topbar meter, from the same roll, so the two can never
+    // disagree. A SIBLING of `.body`, not a child: `paintStream` assigns the
+    // body's `textContent` on the first chunk, which deletes everything inside
+    // it — the dots go with it deliberately, and this must not.
+    //
+    // Starts hidden and empty. A fresh turn has measured nothing yet, and the
+    // `0 tokens` that would fill this line is the exact fabrication `fmtRoll`
+    // refuses to print.
+    const tokens = document.createElement('span');
+    tokens.className = 'typing-tokens';
+    tokens.hidden = true;
+    pendingEl.appendChild(tokens);
     if (cancellable) {
       const cancelBtn = document.createElement('button');
       cancelBtn.type = 'button';
@@ -4283,8 +4446,10 @@ async function send() {
   // Sent whether or not the fan-out is ticked: the fan-out is enabled by the
   // model id the pooled class sends, so a turn that never entered autonomous
   // mode still ran pooled and had no way to say how big it should be — and a
-  // DeepSeek reasoning model needs it to size its CoT. `undefined` = "auto" =
-  // the server (or the engine's rung default) infers it.
+  // DeepSeek reasoning model needs it to size its CoT. It is always a rung now
+  // (effortFor floors to `high`), never "state no opinion", because a pooled
+  // call that states nothing is sized by the server's own default instead of
+  // the level shown in the select.
   const effort = effortFor();
   const maxTokens = budgetFor(model, undefined, effort);
   const workers = autonomous ? parseInt(els.autonomousWorkers.value, 10) || undefined : undefined;
@@ -4310,6 +4475,13 @@ async function send() {
   threadMessages.push({ role: 'user', content: prompt });
 
   setBusy(true, { cancellable: true });
+  // The counter exists from the frame the turn does, not from its first chunk.
+  // Both live surfaces this one mirrors have a figure on screen from the start
+  // (`cli/src/chatflow.js`'s spinner tail reads `↓0 tokens` on its first render;
+  // the reference engine's count climbs from t=0), and this bubble used to open
+  // with an empty line and pop a number in a second later. Painting here also
+  // means the reader never sees the row without the figure it will carry.
+  if (pendingEl) renderRollMeter(sessionId, { prompt, reply: '', reasoning: '' });
   // Sending is an explicit act, so it always returns the view to the tail.
   // This is the single moment the auto-scroll overrides the reader's scroll.
   stickToBottom({ force: true });
@@ -4328,7 +4500,16 @@ async function send() {
   // construction (declared here, not at module scope), so a new turn starts its
   // preview fresh — see `liveMeterDue` for why the meter is not recomputed on
   // every frame.
-  let meterChars = 0;
+  //
+  // Null, NOT 0: unset means "nothing painted for this turn yet", which
+  // `liveMeterDue` reads as due on the first chunk. Seeded at 0 it read as
+  // "measured an empty stream", so the turn's first paint waited out a full
+  // step of the rule — a quarter kilobyte of text, ~64 tokens, seconds into a
+  // slow turn — and the bubble sat with no figure at all and then jumped to it.
+  // The CLI's spinner tail has no such dead zone (it prints `↓0 tokens` from
+  // the first frame), so the two surfaces disagreed about when a count begins
+  // existing.
+  let meterChars = null;
 
   // Text arrives in dozens of small chunks per second; painting each one is
   // what made the window feel locked up. One paint per frame, off the latest
@@ -4420,7 +4601,7 @@ async function send() {
     if (data && data.model) bits.push(`model: ${data.model}`);
     else if (model) bits.push(`model: ${model}`);
     bits.push(classLabel(cls));
-    if (autonomous) bits.push(`autonomous (${effort || 'auto'}, ${workers || 'auto'}w)`);
+    if (autonomous) bits.push(`autonomous (${effort}, ${workers || 'auto'}w)`);
     // The budget rung is worth showing even without the fan-out: on the pooled
     // class it is what sized the call, and a user cannot tell a 16k turn from a
     // 64k one by looking at the answer.
@@ -4431,26 +4612,42 @@ async function send() {
     // alone left this surface with no comparable meter at all — the desktop
     // and the CLI run the same engine, so a gap between them had to be
     // measured on the same prompt, and one side was not measuring.
+    //
+    // The figure is the OUTPUT (`displayTokens`), not the wire's total: the
+    // total is input + output, and on a cached turn the input half is the
+    // larger one, so `tokens: 3,145` on a turn that wrote 145 tokens read as a
+    // model emitting twenty times what it did. Same rule as the CLI's
+    // `fmtsUsageSplit`, and the same one `fmtRoll` now uses below — the two
+    // figures on this row are the same quantity for the same reason.
     const turn = turnAccounting(data && data.usage, model, {
       costUsd: data && typeof data.costUsd === 'number' ? data.costUsd : undefined,
     });
-    if (turn.tokens != null) bits.push(`tokens: ${turn.tokens}`);
+    const produced = displayTokens(turn);
+    if (produced != null) bits.push(`tokens: ${produced}`);
     // A turn the wire did not report on still gets a figure — the same text
     // estimate that goes into the session total, marked `~` so an inferred
     // count is never read as a reported one. Printing nothing here while the
     // session total moved was the other half of "the counter looks dead".
+    // Output only, like the reported figure beside it: `est.input` is the
+    // prompt, and summing the two is the very reading this change removes.
     else {
       const est = estimatedBuckets(prompt, text, text === reasoningText ? '' : reasoningText);
-      if (est) bits.push(`~${est.input + est.output} tokens`);
+      if (est && est.output > 0) bits.push(`~${est.output} tokens`);
     }
-    if (turn.cost != null) bits.push(fmtCost(turn.cost, turn.real));
+    // No money on a tier AEGIS bills no fee to, and none from a snapshot that
+    // has not proven a fee is owed — see `feeBillable` in usage.js, which is the
+    // CLI's exact rule. Not a `$0.0000` in its place: a zero states a price, and
+    // this account has no proven price on this turn. The token figure above is
+    // unaffected, so the row keeps its meter either way.
+    const billable = feeBillable(entitlement());
+    if (turn.cost != null && billable) bits.push(fmtCost(turn.cost, turn.real));
     // …and on the byok class, whose money that figure is. The relay never
     // returns a settled charge (nothing on that route emits one), so this is
     // always the rate table's estimate of the caller's OWN provider bill — and
     // AEGIS additionally collects a handling fee on the same turn, which this
     // response cannot price. One bit, and the number stops reading as the whole
     // cost of a BYOK turn.
-    if (cls === 'byok' && turn.cost != null) {
+    if (cls === 'byok' && turn.cost != null && billable) {
       bits.push('your provider bill (est.) + AEGIS handling fee');
     }
     // …AND the running session total beside it, which is the number the CLI
@@ -4473,7 +4670,7 @@ async function send() {
       // estimated twice if a turn ever collapses the two into one.
       reasoning: text === reasoningText ? '' : reasoningText,
     });
-    const rollLine = fmtRoll(roll);
+    const rollLine = fmtRoll(roll, { omitMoney: !billable });
     if (rollLine) bits.push(`session: ${rollLine}`);
     addMessage('assistant', text, bits.join(' · ') || undefined, sessionId, toolLog);
 
@@ -4548,10 +4745,14 @@ async function send() {
       });
       const stopBits = ['stopped by you'];
       if (salvage.kind === 'reasoning-only') stopBits.push('reasoning only');
-      if (turn.tokens != null) stopBits.push(`tokens: ${turn.tokens}`);
+      // The same figure and the same rule as the completed row above, so a
+      // stopped turn and a finished one report one quantity. `displayTokens`
+      // rather than `turn.tokens` — see the note there.
+      const stopProduced = displayTokens(turn);
+      if (stopProduced != null) stopBits.push(`tokens: ${stopProduced}`);
       else {
         const est = estimatedBuckets(prompt, text, salvageReasoning);
-        if (est) stopBits.push(`~${est.input + est.output} tokens`);
+        if (est && est.output > 0) stopBits.push(`~${est.output} tokens`);
       }
       const stopRollLine = fmtRoll(roll);
       if (stopRollLine) stopBits.push(`session: ${stopRollLine}`);
@@ -4650,17 +4851,21 @@ async function init() {
     updateAutonomousControlsVisibility();
   });
 
-  // The one budget control: which rung sizes the call, or "auto" to let the
-  // server infer it from the ask (aegis1 services/pool_brain.py
-  // parse_brain_request). Applies to EVERY class now — with the max-tokens
-  // dropdown gone there is nothing else that sizes a call — so it is no longer
-  // stored under the autonomous-mode namespace; an install predating the rename
-  // is read from the old key once, and a stored rung this build's list no
-  // longer offers falls through to the markup's default rather than assigning
-  // an option that does not exist.
+  // The one budget control: which rung sizes the call (low | medium | high).
+  // Applies to EVERY class now — with the max-tokens dropdown gone there is
+  // nothing else that sizes a call — so it is no longer stored under the
+  // autonomous-mode namespace; an install predating the rename is read from
+  // the old key once, and a stored rung this build's list no longer offers
+  // falls through to the markup's default rather than assigning an option that
+  // does not exist. That fall-through is load-bearing for the retired `auto`
+  // value: a window that had `auto` persisted restores `high`, and the stale
+  // string is rewritten so the next launch reads a rung that is really offered.
   const savedEffort = localStorage.getItem(EFFORT_KEY) || localStorage.getItem(LEGACY_EFFORT_KEY);
-  if (savedEffort && Array.from(els.effortSelect.options).some((o) => o.value === savedEffort)) {
+  const offered = Array.from(els.effortSelect.options).some((o) => o.value === savedEffort);
+  if (savedEffort && offered) {
     els.effortSelect.value = savedEffort;
+  } else if (savedEffort) {
+    localStorage.setItem(EFFORT_KEY, els.effortSelect.value);
   }
   els.effortSelect.addEventListener('change', () => {
     localStorage.setItem(EFFORT_KEY, els.effortSelect.value);

package/renderer/index.html

@@ -25,7 +25,7 @@
     <!-- The rolling session token total, counted the way the CLI counts it:
          every finished turn folded into one running number rather than a
          per-turn count that resets. Hidden until a turn has been accounted
-         for, so an untouched thread never shows a `0 tok` it never measured. -->
+         for, so an untouched thread never shows a `0 tokens` it never measured. -->
     <div class="session-meter" id="session-meter" hidden></div>
     <div class="spacer"></div>
     <button type="button" id="new-chat" class="ghost-btn">New chat</button>
@@ -138,8 +138,7 @@
           <select id="effort-select">
             <option value="low">low</option>
             <option value="medium">medium</option>
-            <option value="high">high</option>
-            <option value="auto" selected>auto</option>
+            <option value="high" selected>high</option>
           </select>
         </div>
 

package/renderer/stream-policy.js

@@ -207,8 +207,23 @@ function isPlaceholderContent(content) {
   );
 }
 
-/** The smallest stream growth, in characters, that earns a live-meter recompute. */
-const LIVE_METER_MIN_GROWTH = 256;
+/** The smallest stream growth, in characters, that earns a live-meter recompute.
+ *
+ *  It was 256, and that number was the start-of-turn lag this rule exists to
+ *  avoid: the counter's first paint required a quarter kilobyte of text — ~64
+ *  tokens, several seconds into a slow turn — so the bubble opened with no
+ *  figure at all and then jumped to it, while the CLI's own tail
+ *  (`cli/src/chatflow.js`'s spinner, `↓${fmtTokens(state.streamed)}`) and the
+ *  reference engine both have a count climbing from the first frame. 32 chars
+ *  (~8 tokens) is a step the eye reads as continuous at the start of a reply,
+ *  which is the whole point of a live count.
+ *
+ *  The cost bound is NOT this number — it is the proportional term below. At
+ *  100k chars the step is 1/32 of the stream (3125), so lowering this floor
+ *  leaves the long-reply recompute count unchanged; it only buys paints in the
+ *  first ~1k characters, where each estimate is over a string too short to
+ *  matter. */
+const LIVE_METER_MIN_GROWTH = 32;
 
 /** …and the fraction of the whole stream that must have arrived since the last
  *  one: a recompute comes due once the stream has grown by 1/this. */
@@ -241,6 +256,13 @@ const LIVE_METER_GROWTH_FRACTION = 32;
  */
 function liveMeterDue(measured, streamChars) {
   const now = Number(streamChars) || 0;
+  // Nothing has been painted yet this turn. The cursor is per-turn and starts
+  // UNSET (see app.js `let meterChars = null`), and an unset cursor must not be
+  // read as "measured an empty stream" — that made the first paint wait out the
+  // whole step below, which is the start-of-turn dead zone. The first text to
+  // arrive paints, so the figure is on screen from the first chunk rather than
+  // from the first 32nd of the reply.
+  if (measured === null || measured === undefined) return now > 0;
   const grown = now - (Number(measured) || 0);
   if (grown <= 0) return false;
   const step = Math.max(LIVE_METER_MIN_GROWTH, Math.floor(now / LIVE_METER_GROWTH_FRACTION));

package/renderer/style.css

@@ -148,6 +148,15 @@ body {
   display: none;
 }
 
+/* A total that is still climbing has to look different from one that has
+   stopped, or "is it still working?" is answered by watching for the absence
+   of change. Set by `renderRollMeter` from the same `live` flag that makes the
+   figure an estimate in the first place. */
+.session-meter.live {
+  color: var(--accent);
+  border-color: var(--accent);
+}
+
 .spacer {
   flex: 1;
 }
@@ -876,21 +885,31 @@ body.memory-open {
   text-align: center;
 }
 
+/* Dimmed by COLOR, not by `opacity`. The working indicator lives inside this
+   bubble, and `opacity` is inherited by everything painted under it — so the
+   0.6 that was meant to fade placeholder prose also faded the dots, which
+   already sat on `--text3` (#3a4a60). Two dims multiplied on the one element
+   whose entire job is to be seen: the composite was about #232c3a on a dark
+   surface, i.e. the spinner was effectively invisible (reported as "too
+   transparent"). A color dim cannot compound like that. */
 .msg.pending {
-  opacity: 0.6;
+  color: var(--text2);
 }
 
 .typing-dots {
   display: inline-flex;
   align-items: center;
-  gap: 5px;
+  gap: 6px;
 }
 
+/* 8px and `--text2` at rest, not 6px and `--text3`: the pulse should read as
+   motion on top of a visible indicator, not as the indicator briefly
+   appearing out of nothing twice a second. */
 .typing-dots span {
-  width: 6px;
-  height: 6px;
+  width: 8px;
+  height: 8px;
   border-radius: 50%;
-  background: var(--text3);
+  background: var(--text2);
   animation: typing-glow 1.2s ease-in-out infinite;
 }
 
@@ -910,15 +929,38 @@ body.memory-open {
   0%,
   60%,
   100% {
-    background: var(--text3);
+    background: var(--text2);
     box-shadow: none;
+    transform: scale(1);
   }
   30% {
     background: var(--accent);
-    box-shadow: 0 0 6px 1px var(--accent);
+    box-shadow: 0 0 9px 2px var(--accent);
+    transform: scale(1.25);
   }
 }
 
+/* The live token figure, beside the spinner rather than only in the topbar.
+   Reported as "I don't see the tokens when AI is working": the rolling total
+   was already live, but it was 40ch away in the topbar and muted to `--text2`,
+   so it read as a settled readout. Here it is where the reader is already
+   looking, in the accent the pulse uses. */
+.typing-tokens {
+  display: block;
+  margin-top: 8px;
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--accent);
+  white-space: nowrap;
+}
+
+/* Same reason `.session-meter[hidden]` exists: the rule above sets a display,
+   which would otherwise win over the `hidden` attribute and leave an empty
+   accent line under every fresh turn. */
+.typing-tokens[hidden] {
+  display: none;
+}
+
 .who {
   font-size: 11px;
   font-weight: 600;

package/renderer/usage.js

@@ -609,14 +609,23 @@ function usageCost(usage, model, opts = {}) {
  * @param {object|null|undefined} usage  the response's `usage` object
  * @param {string} model                 the model id that answered
  * @param {{costUsd?: number}} [opts]    the server-settled charge, if any
- * @returns {{tokens: number|null, cost: number|null, real: boolean, estimated: boolean}}
+ * @returns {{tokens: number|null, output: number|null, cost: number|null,
+ *           real: boolean, estimated: boolean}}
  *          `real` is true only when `cost` is the settled charge. `cost` is
  *          `null` when nothing was reported and no model was named — an
  *          unpriced turn must render as nothing, never as $0.0000.
+ *          `tokens` is the wire's TOTAL (input + output) and is what the ledger
+ *          and the rolling fold need; `output` is the half a person reads, and
+ *          it is what every per-turn surface shows (see `displayTokens`).
  */
 function turnAccounting(usage, model, opts = {}) {
   const tokens = usageTokens(usage);
   const u = usage && typeof usage === 'object' ? usage : {};
+  // The half the turn PRODUCED. Kept beside the total rather than replacing it:
+  // `tokens` still has to fold the ledger, and a rebuild from stored buckets
+  // must agree with the live fold to the unit.
+  const output =
+    usage && typeof usage === 'object' ? usageBuckets(usage).output : null;
   // The settled charge can arrive either on the response or folded into the
   // usage object — the upstream engine does the latter
   // (`{ ...result.usage, costUsd: result.costUsd }`), so both are accepted.
@@ -628,15 +637,23 @@ function turnAccounting(usage, model, opts = {}) {
     // because a settled charge is a fact and a table match is a guess — and the
     // pool's bill carries a margin and a prompt-cache discount this table
     // cannot see, so the two must never be averaged or confused.
-    return { tokens, cost: settled, real: true, estimated: false, basis: 'settled', priced: true };
+    return {
+      tokens, output, cost: settled, real: true, estimated: false, basis: 'settled', priced: true,
+    };
+  }
+  if (tokens == null) {
+    return {
+      tokens, output, cost: null, real: false, estimated: false, basis: null, priced: false,
+    };
   }
-  if (tokens == null) return { tokens, cost: null, real: false, estimated: false, basis: null, priced: false };
   const b = costBreakdown(u, model, opts);
   // A model the table cannot place still yields a number (ratesFor never
   // returns nothing), so this is always an estimate — but `priced: false` says
   // the figure is a placeholder rather than this model's rate, so the caller
   // can label it instead of printing it as though it had been measured.
-  return { tokens, cost: b.cost, real: false, estimated: true, basis: b.basis, priced: b.priced };
+  return {
+    tokens, output, cost: b.cost, real: false, estimated: true, basis: b.basis, priced: b.priced,
+  };
 }
 
 /**
@@ -648,7 +665,7 @@ function turnAccounting(usage, model, opts = {}) {
  * — `tokens`, `inputTokens`, `outputTokens`, `calls` — and what the user reads
  * back is that RUNNING TOTAL. The status bar prints `state.tokens`
  * (renderStatus), and `ctrl+t` prints the tallies in one line
- * (`tokenSummary`: `12,400 tok (10,100 in / 2,300 out) · 4 calls · €0.03`).
+ * (`tokenSummary`: `12,400 tokens (10,100 in / 2,300 out) · 4 calls · €0.03`).
  * The tallies are reproduced; that one abbreviation is not — `fmtRoll` explains
  * why it drops the parenthetical rather than carrying the CLI's line verbatim.
  *
@@ -869,36 +886,104 @@ function fmtTokens(n) {
     .replace(/\B(?=(\d{3})+(?!\d))/g, ',');
 }
 
+/**
+ * The token figure a person is SHOWN for a finished turn or a session roll.
+ *
+ * One authority, because there are two shapes that reach it and they had
+ * drifted apart: `turnAccounting` (a single dispatch, `{tokens, output}`) and
+ * `emptyRoll`/`rollTurn` (a session tally, same two fields). Every per-turn row
+ * and the topbar both route through here, so no surface can print a different
+ * quantity than another.
+ *
+ * What it returns is the OUTPUT — what the turn produced. The wire's total is
+ * input + output, and on any cached or long-context turn the input half
+ * dominates it: a 3,145-token call whose prompt was 3,000 tokens is a turn that
+ * wrote 145. Showing 3,145 beside a `session:` line that also reads 3,145 told
+ * the reader the model had emitted ten times what it did, and there is no way
+ * to tell from the row which of the two numbers is the prompt restated. The
+ * CLI settled this the same way (`fmtUsageSplit`, cli/src/format.js): the figure
+ * is the output, and the input half is not shown unlabelled beside it.
+ *
+ * It does NOT fall back to the total. Fall back to `tokens` and the input half
+ * is back on the screen with no label: a wire that priced a turn but did not
+ * itemise it would print `3,145` for a turn that wrote 145. Returns `null`
+ * rather than `0` in that case — `0 tokens` is a figure no provider sent,
+ * and this file refuses that fabrication everywhere else (`fmtRoll`).
+ *
+ * @param {{tokens?: number|null, output?: number|null}} [source]
+ * @returns {number|null}
+ */
+function displayTokens(source) {
+  if (!source || typeof source !== 'object') return null;
+  // The half the turn PRODUCED, from either shape this file is handed: an
+  // accounting or roll record (`output`), or a stored token bucket
+  // (`tokens: {output}` — what `rollMessages` reads back out of the shared
+  // store, and what a rebuilt session presents).
+  const nested = source.tokens;
+  const candidates = [source.output];
+  if (nested && typeof nested === 'object') {
+    candidates.push(nested.output, nested.output_tokens, nested.completion_tokens);
+  } else {
+    candidates.push(source.output_tokens, source.completion_tokens);
+  }
+  for (const c of candidates) {
+    if (typeof c === 'number' && isFinite(c) && c > 0) return c;
+  }
+  // The wire's TOTAL is deliberately NOT a fallback here. `tokens` is
+  // input + output, and on a cached turn the input half is the larger one, so
+  // falling back to it put back the exact reading this rule exists to remove:
+  // `tokens: 3,145` on a turn that wrote 145. This was the last surviving
+  // place the input half reached the screen — the split had been dropped, and
+  // the total it fell back to still carried it.
+  //
+  // Stated once more, because it is the whole point: a turn the wire priced but
+  // did not itemise has NO output figure, and inventing one from the total
+  // would be a number no provider sent. That turn's row states its own text
+  // estimate instead (`~N tokens`), which is at least a figure about what was
+  // written.
+  return null;
+}
+
 /**
  * The rolling session total as one line — the desktop's counterpart of the
  * CLI's `tokenSummary`. Empty string when nothing has been accounted for, so
  * an untouched session adds no noise to a turn's meta line.
  *
  * @param {object} [roll]
- * @returns {string} e.g. `12,400 tok · 4 calls · $0.0310` — the CLI's fields in
- *   the CLI's order, minus the input/output parenthetical (see below).
+ * @returns {string} e.g. `2,300 tokens · 4 calls · $0.0310` — the CLI's fields in
+ *   the CLI's order, minus the input/output parenthetical (see below). The
+ *   figure is the OUTPUT (see `displayTokens`).
  */
-function fmtRoll(roll) {
+function fmtRoll(roll, opts = {}) {
   const r = roll || emptyRoll();
   if (!r.turns && !r.calls) return '';
   // The fields are `tokenSummary`'s (cli/src/app.js:1413) in its order — tokens,
   // calls, money — with one dropped: the `(10,100 in / 2,300 out)` split. `in`
   // and `out` are a terminal status-line shorthand, legible to someone already
   // reading that status line and to nobody else, which is what an unlabelled
-  // abbreviation in a GUI topbar turns into. The total is the figure a reader
-  // wants; `r.input`/`r.output` are still folded onto the roll (see `rollTurn`)
-  // for any surface that wants to show the split with real labels. The call
-  // count stays unconditional, because it is the number that reveals a
-  // fan-out, and it is not hidden at 1.
+  // abbreviation in a GUI topbar turns into.
+  //
+  // …and the figure that remains is the OUTPUT, not the wire's total. This line
+  // used to print `r.tokens`, which is input + output: on a cached turn the
+  // prompt restated is the larger half, so a session that wrote 2,300 tokens on
+  // a 10,100-token prompt read `12,400 tokens` and looked like a model emitting
+  // five times what it did. The parenthetical was not the only place the input
+  // half showed up — it was in the total too, and dropping the split alone left
+  // the reader comparing two numbers that were both mostly their own prompt.
+  // `displayTokens` holds the rule, the same one the CLI's `fmtUsageSplit` uses.
+  // `r.input` is still folded onto the roll (see `rollTurn`) for any surface
+  // that wants to show the split with real labels.
   const bits = [];
   // The token half only when something was actually counted. `rollTurn` counts
   // turns and calls BEFORE it looks at the token count, so a dispatch that
-  // reported nothing still reaches here — and printing its empty tally would
-  // put `0 tok` on the topbar, a figure the meter never took, which reads as a
-  // counter that does not move. The turn count is still stated, because that
-  // much is true.
-  if (r.tokens > 0) {
-    bits.push(`${fmtTokens(r.tokens)} tok`);
+  // reported nothing still reaches here — and printing an empty tally would put
+  // `0 tokens` on the topbar, a figure the meter never took, which reads as a
+  // counter that does not move. `displayTokens` returns null rather than 0 for
+  // exactly that case, and falls back to the total only when no split arrived.
+  // The turn count is still stated, because that much is true.
+  const produced = displayTokens(r);
+  if (produced != null) {
+    bits.push(`${fmtTokens(produced)} tokens`);
   }
   bits.push(`${r.calls} call${r.calls === 1 ? '' : 's'}`);
   // Money is where this line departs from `tokenSummary`, deliberately: that
@@ -906,7 +991,10 @@ function fmtRoll(roll) {
   // a settled charge and a local estimate apart so a `~`-estimate can never be
   // read as part of the bill. Desktop's pre-existing fmtCost renders both, and
   // its `$` convention is left exactly as it was.
-  if (r.cost > 0 || r.estimate > 0) {
+  // Money is omitted entirely on a tier AEGIS does not bill a fee to
+  // (`opts.omitMoney` — see `feeWaived`). Not zeroed, not marked `~`: a `$0.0000`
+  // states a price, and this account has no price on this turn.
+  if (!opts.omitMoney && (r.cost > 0 || r.estimate > 0)) {
     const money = [];
     if (r.cost > 0) money.push(fmtCost(r.cost, true));
     if (r.estimate > 0) money.push(fmtCost(r.estimate, false));
@@ -935,11 +1023,108 @@ function fmtRoll(roll) {
  */
 function fmtCost(cost, real) {
   if (typeof cost !== 'number' || !isFinite(cost)) return '';
+  // The `$` is not decoration: its loss was a regression, not a decision.
+  // `4d5d1e9` introduced this function with it (`~$18.0000`); `6d48470` — a
+  // commit about the token TOTAL, unrelated to money — dropped it as a stray
+  // hunk. Every desktop turn row then painted a bare `18.0000`, a number with no
+  // currency on it, where the CLI paints `€0.03` for the same figure.
   return `${real ? '' : '~'}$${cost.toFixed(4)}`;
 }
 
+/**
+ * True when this account's tier means AEGIS bills no per-turn fee, so no money
+ * figure belongs on a turn row or a session roll.
+ *
+ * The fee in question is the BYOK handling fee — the only charge AEGIS adds on
+ * top of a caller's own provider bill — and aegis1 waives it on Unlimited:
+ * `lib/local/entitlement.js` states the rule in as many words ("the throughput
+ * allowance and the BYOK fee waiver are `is_unlimited()`-gated"), and the tier
+ * a welcome trial grants IS Unlimited (a 30-day `unlimited` row in
+ * `subscriptions`, which `register_device` writes in the same request that mints
+ * the key). So a trial account resolves here exactly like a paying one, which is
+ * what "trial unlimited" means — the trial is not a separate tier with its own
+ * money rule, it is Unlimited for 30 days.
+ *
+ * Matching is on the resolved tier rather than `pro`: `pro` is "the PLAN is paid
+ * for" and is also true of the €9 tier's aliases, while the waiver is gated on
+ * `unlimited` specifically. A funded bank on a free plan is not a tier at all
+ * (`entitlement.js` refuses to name one) and is therefore NOT waived — that
+ * account pays the fee from the bank, and hiding the number would leave it with
+ * no meter for the only money it spends.
+ *
+ * @param {{tier?: string|null, plan?: string|null, planRaw?: string|null}} [entitlement]
+ * @returns {boolean}
+ */
+function feeWaived(entitlement) {
+  if (!entitlement || typeof entitlement !== 'object') return false;
+  const named = [
+    entitlement.tier,
+    entitlement.plan,
+    entitlement.planRaw,
+    entitlement.subscription,
+    entitlement.subscriptionTier,
+    entitlement.product,
+    // The server's own two fields, as `register_device` writes them: a welcome
+    // trial is a 30-day `unlimited` row in `subscriptions`, and `item`/`sku` is
+    // that row's product name. Naming them here is what keeps a trial account
+    // from resolving to "no tier" and being billed a fee it does not owe.
+    entitlement.item,
+    entitlement.sku,
+  ]
+    .filter((v) => typeof v === 'string')
+    .map((v) => v.trim().toLowerCase());
+  // An explicit boolean outranks every spelling below: aegis1's `is_unlimited()`
+  // verdict is the fact, and the strings are only what it is written as on the
+  // wire. A probe that answers with the bit and not the tier is still an answer.
+  if (entitlement.unlimited === true) return true;
+  if (named.some((v) => v === 'unlimited' || v === 'trial')) return true;
+  // A tier string that merely CONTAINS the word — `unlimited_trial`,
+  // `plan.unlimited`, `Unlimited (trial)` — so a server that decorates the name
+  // cannot put the fee back on an account whose tier is Unlimited.
+  return named.some((v) => /(^|[^a-z])unlimited([^a-z]|$)/.test(v));
+}
+
+/**
+ * Whether a money figure belongs on this account's turn row or session roll.
+ *
+ * The CLI's exact rule (`cli/src/format.js` → `feeBillable`), and it is the same
+ * rule on purpose — the two hosts render the same turn from the same engine, so
+ * a row that shows a fee on one and waives it on the other is a disagreement
+ * about what the user owes.
+ *
+ * A price is printed UNLESS AEGIS either waives it or has not proven it owed:
+ *
+ *  - a tier AEGIS waives (`feeWaived`) → no price. Unlimited, paid or on the
+ *    30-day welcome trial, has no per-turn charge and no bank draw;
+ *  - a snapshot asserting a plan it cannot prove (`degraded`) → no price. The
+ *    entitlement module STARTS at exactly that: `makeFreeSnapshot()` reads
+ *    `plan: 'free'`, `tier: null`, `source: 'unresolved'`, `degraded: true`,
+ *    which says "no verdict yet", not "this account is free". Reading the
+ *    placeholder as a verdict is what put `~$0.0005` and an "AEGIS handling fee"
+ *    line on the turns of trial accounts whose probe had not answered — a fee
+ *    charged in writing to the one account that does not pay it;
+ *  - everything else → the price stands, including when no snapshot exists at
+ *    all. A cost figure is a measurement of the turn, and dropping a real number
+ *    because no tier was published would leave a self-hosted or BYO-key run with
+ *    no meter for money it actually spent.
+ *
+ * The token figure is never gated by this, on any branch: what a turn produced
+ * is not a price, and hiding it would leave an Unlimited account with no meter.
+ *
+ * @param {{tier?: string|null, plan?: string|null, planRaw?: string|null,
+ *   degraded?: boolean, source?: string|null, unlimited?: boolean}} [entitlement]
+ * @returns {boolean}
+ */
+function feeBillable(entitlement) {
+  if (!entitlement || typeof entitlement !== 'object') return true;
+  if (feeWaived(entitlement)) return false;
+  return entitlement.degraded !== true;
+}
+
 if (typeof module !== 'undefined' && module.exports) {
   module.exports = {
+    feeWaived,
+    feeBillable,
     RATES,
     RATE_BASIS,
     UNPRICED_BY_DESIGN,
@@ -951,6 +1136,7 @@ if (typeof module !== 'undefined' && module.exports) {
     usageCost,
     costBreakdown,
     turnAccounting,
+    displayTokens,
     estimateTokens,
     estimatedBuckets,
     emptyRoll,