aegiscode 6.5.0 → 6.5.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegiscode",
   "productName": "AEGIS Code",
-  "version": "6.5.0",
+  "version": "6.5.2",
   "description": "aegiscode \u2014 the command-line version of AEGIS Desktop. The shared tool surface in your shell, over the same thin transport and tool registry as the MCP plugin and the desktop app. Ships transport + UI only; no brain.",
   "author": {
     "name": "AEGIS Code",

package/src/app.js

@@ -1007,9 +1007,15 @@ function createApp(options = {}) {
    * Best-effort by construction: the two writers swallow their own failures, and
    * accounting must never be able to break a turn.
    */
-  function persistTurn(prompt, res, status = 'done') {
+  function persistTurn(prompt, res, status = 'done', costEur = null) {
     try {
       const usage = res && res.usage;
+      // What the POOL charged, straight from the ledger — margin and
+      // prompt-cache discount already applied. Stored so /cost can report the
+      // real bill instead of recomputing from provider rates it cannot see.
+      // (The history field is historically named `costUsd`; the value here is
+      // EUR, which is what every surface in this client displays.)
+      const settled = typeof costEur === 'number' && Number.isFinite(costEur) ? costEur : null;
       appendHistory({
         sessionId: commandCtx.sessionId,
         prompt,
@@ -1021,8 +1027,11 @@ function createApp(options = {}) {
               output: Number(usage.output_tokens ?? usage.completion_tokens ?? 0) || 0,
               cacheRead: Number(usage.cache_read_input_tokens ?? 0) || 0,
               cacheWrite: Number(usage.cache_creation_input_tokens ?? 0) || 0,
+              ...(settled != null ? { costUsd: settled } : {}),
             }
-          : null,
+          : settled != null
+            ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: settled }
+            : null,
       });
       snapshotCheckpoint(commandCtx.sessionId, transcript);
     } catch {

package/src/chatflow.js

@@ -66,11 +66,28 @@ const FRAME_MS = 33; // ~30fps cap for streaming repaints
 
 // ── pure turn helpers ───────────────────────────────────────────────────────
 
+/**
+ * The shipped engine's shell tool is `exec` and its subagent tool is `task`
+ * (desktop/lib/local/tools.js). `Bash`/`Task` are Claude Code's names for the
+ * same two capabilities — this file was written against the reference's
+ * registry, so every branch below keyed on the reference's spelling and missed
+ * the tools that actually arrive: a shell row read "exec command" instead of
+ * "shell command", and a subagent row read "task command". Both spellings are
+ * accepted so either registry renders identically.
+ */
+function isShellTool(name) {
+  return name === 'exec' || name === 'Bash';
+}
+
+function isAgentTool(name) {
+  return name === 'task' || name === 'Task';
+}
+
 /** The noun a tool row uses: "shell command", "subagent", "read command"… */
 function toolLabel(name, n) {
   const base =
-    name === 'Bash' ? 'shell command'
-      : name === 'Task' ? 'subagent'
+    isShellTool(name) ? 'shell command'
+      : isAgentTool(name) ? 'subagent'
         : `${String(name).toLowerCase()} command`;
   return n > 1 ? base + 's' : base;
 }
@@ -120,14 +137,22 @@ function resolveToolDone(transcript, t) {
  * fall back to "(no response)" for empty text. An abort wins over an error so
  * Esc-cancel never produces the doubled marker.
  */
-function finalizeTurnText(text, { aborted, error } = {}) {
+function finalizeTurnText(text, { aborted, error, reasoned } = {}) {
   let t = String(text == null ? '' : text);
   if (error && !aborted && error !== 'stopped') {
     const err = `(backend error: ${error})`;
     t = t.trim() ? `${t.trimEnd()}\n\n${err}` : err;
   }
   if (aborted) t = t.trim() ? `${t.trimEnd()} (stopped)` : '(stopped)';
-  if (!t.trim()) t = '(no response)';
+  if (!t.trim()) {
+    // A reasoning model that spends its whole token budget on hidden
+    // chain-of-thought finishes with empty content and no error. "(no
+    // response)" reads as a broken client for what is really an exhausted
+    // budget, and sends you looking for a bug that is not there.
+    t = reasoned
+      ? '(no answer — the model used its whole budget on hidden reasoning before writing one; retry, or raise the budget with /effort)'
+      : '(no response)';
+  }
   return t;
 }
 
@@ -234,10 +259,15 @@ function confirmLines(overlay, cols, ctx) {
   const t = themeOf(ctx);
   const lines = [];
   lines.push([span(t.gray, '─'.repeat(Math.min(Math.max(10, cols - 4), 80)))]);
-  lines.push([span(t.white, `${overlay.name} command`)]);
+  lines.push([span(t.white, `${isShellTool(overlay.name) ? 'shell' : overlay.name} command`)]);
   lines.push([span('', '')]);
+  // `exec` carries its subject in `command`; readFile/writeFile/editFile in
+  // `file_path`; glob/grep in `pattern`. Keying this on the reference's `Bash`
+  // sent every shell approval into the file branch, so the dialog that asks
+  // "Do you want to proceed?" showed an empty body — you were approving a
+  // command you could not see.
   const subject =
-    overlay.name === 'Bash'
+    isShellTool(overlay.name)
       ? String((overlay.args && overlay.args.command) || '')
       : String((overlay.args && (overlay.args.file_path || overlay.args.pattern)) || '');
   for (const l of wrapBlock(subject, Math.max(8, cols - 4))) lines.push([span(t.gray, l)]);
@@ -255,6 +285,38 @@ function confirmLines(overlay, cols, ctx) {
   return lines;
 }
 
+/**
+ * The accounting bits for a turn — model, tokens, the in/out split, €, elapsed
+ * and call count. Shared by the standalone `meta` row and the folded footer, so
+ * the two can never drift apart.
+ *
+ * `omitMs` drops the client-call time: when the bits ride on the `✻ Churned for
+ * 6s` row, that row already states the wall time, and printing a second,
+ * slightly different duration beside it reads as a discrepancy.
+ */
+function metaBits(m, t, { omitMs = false } = {}) {
+  const bits = [];
+  if (m.model) bits.push(span(t.blue, m.model));
+  if (m.tokens != null) bits.push(span(t.white, `${fmtTokens(m.tokens)} tok`));
+  if (m.input != null || m.output != null) {
+    bits.push(span(t.gray, `${fmtTokens(m.input || 0)}/${fmtTokens(m.output || 0)}`));
+  }
+  if (m.eur != null) bits.push(span(m.eur > 0 ? t.coral : t.green, fmtEur(m.eur)));
+  if (m.ms != null && !omitMs) bits.push(span(t.gray, fmtElapsed(m.ms)));
+  if (m.calls > 1) bits.push(span(t.gray, `${m.calls} calls`));
+  return bits;
+}
+
+/** Interleave accounting bits with the `·` separator. */
+function joinBits(bits, t) {
+  const line = [];
+  bits.forEach((b, i) => {
+    if (i) line.push(span(t.dim, ` ${GLYPH.bullet} `));
+    line.push(b);
+  });
+  return line;
+}
+
 /** Render one transcript row to span lines. */
 function rowLines(msg, cols, ctx, now = Date.now()) {
   const t = themeOf(ctx);
@@ -285,32 +347,24 @@ function rowLines(msg, cols, ctx, now = Date.now()) {
     return out;
   }
   if (msg.role === 'done') {
-    // Real 2.1.211: "✻ Churned for 6s" — bloom glyph + gray text.
-    out.push([span(t.gray, GLYPH.bloom), span(t.gray, ` ${msg.text}`)]);
+    // Real 2.1.211: "✻ Churned for 6s" — bloom glyph + gray text. The turn's
+    // accounting rides on this same row (see the turn's finally block): one
+    // footer per turn instead of a done row plus a second `⎿` row beneath it.
+    const line = [span(t.gray, GLYPH.bloom), span(t.gray, ` ${msg.text}`)];
+    if (msg.meta) {
+      const bits = metaBits(msg.meta, t, { omitMs: true });
+      if (bits.length) line.push(span(t.dim, '  '), ...joinBits(bits, t));
+    }
+    out.push(line);
     return out;
   }
   if (msg.role === 'meta') {
     // Deliberate divergence from the reference: this client's reason to exist
     // is showing what a turn consumed, so the accounting line is a transcript
-    // row rather than something only /cost can reveal.
-    const m = msg.meta || {};
-    const bits = [];
-    if (m.model) bits.push(span(t.blue, m.model));
-    if (m.tokens != null) bits.push(span(t.white, `${fmtTokens(m.tokens)} tok`));
-    if (m.input != null || m.output != null) {
-      bits.push(span(t.gray, `${fmtTokens(m.input || 0)}/${fmtTokens(m.output || 0)}`));
-    }
-    if (m.eur != null) bits.push(span(m.eur > 0 ? t.coral : t.green, fmtEur(m.eur)));
-    if (m.ms != null) bits.push(span(t.gray, fmtElapsed(m.ms)));
-    if (m.calls > 1) bits.push(span(t.gray, `${m.calls} calls`));
-    if (bits.length) {
-      const line = [span(t.dim, `${GLYPH.hook}  `)];
-      bits.forEach((b, i) => {
-        if (i) line.push(span(t.dim, ` ${GLYPH.bullet} `));
-        line.push(b);
-      });
-      out.push(line);
-    }
+    // row rather than something only /cost can reveal. Kept for rows that have
+    // no `done` row to fold into (and for hosts that emit it standalone).
+    const bits = metaBits(msg.meta || {}, t);
+    if (bits.length) out.push([span(t.dim, `${GLYPH.hook}  `), ...joinBits(bits, t)]);
     return out;
   }
   if (msg.role === 'panel') {
@@ -463,7 +517,11 @@ function inputStart(buf, scroll) {
  */
 function inputLine(state, cols, ctx) {
   const t = themeOf(ctx);
-  const line = [span(t.gray, GLYPH.cursor), span('', ' '), span('', ' ')];
+  // Two cells ("❯ "), matching the reference. The cursor columns below are all
+  // `3 + w(text before the caret)`, which is only correct if the typed text
+  // starts in cell 3 — a third prefix cell pushed the text to cell 4 and left
+  // the caret one cell short, i.e. sitting *on* the last typed character.
+  const line = [span(t.gray, GLYPH.cursor), span('', ' ')];
   if (state.inputPrompt) {
     line.push(span(t.white, `${state.inputPrompt.title}: `));
     for (const ch of [...state.inputPrompt.buf]) line.push(span(t.white, ch));
@@ -732,6 +790,7 @@ async function runSession(host) {
 
     push({ role: 'user', text: prompt });
     const msg = push({ role: 'assistant', text: '', streaming: true });
+    let sawReasoning = false;
 
     const presenter = {
       text: (delta) => {
@@ -739,7 +798,10 @@ async function runSession(host) {
         streamedChars += w(delta);
         scheduleRender();
       },
-      reasoning: () => {},
+      // Not rendered (deliberation is not an answer), but recorded: a turn
+      // that reasoned and then produced nothing needs a different explanation
+      // from one that produced nothing at all.
+      reasoning: () => { sawReasoning = true; },
       tool: (tool) => {
         if (tool.phase === 'run') {
           const n = ++toolSeq;
@@ -776,14 +838,30 @@ async function runSession(host) {
       result = { error: (err && err.message) || String(err) };
     } finally {
       msg.streaming = false;
+      // The row is built from streamed deltas, but the transport is the
+      // authority on what the turn actually produced. A provider that emits
+      // no incremental content — a non-streaming fallback, a gateway that
+      // only sends the finished message, a reasoning model whose visible
+      // answer arrives in one final frame — left this row empty and the user
+      // read "(no response)" for a turn that was answered and billed.
+      if (!String(msg.text || '').trim() && result && typeof result.text === 'string' && result.text.trim()) {
+        msg.text = result.text;
+      }
       working = false;
       clearInterval(spinnerTimer);
       spinnerTimer = null;
       setTitle('AEGIS Code', false);
       const secs = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
       const abortedFlag = !!(abort && abort.signal.aborted);
-      msg.text = finalizeTurnText(msg.text, { aborted: abortedFlag, error: result && result.error });
-      push({ role: 'done', text: `${toolSeq > 0 ? DONE_VERBS[1] : DONE_VERBS[0]} for ${secs}s` }, { follow: false });
+      msg.text = finalizeTurnText(msg.text, {
+        aborted: abortedFlag,
+        error: result && result.error,
+        reasoned: sawReasoning,
+      });
+      const footer = push(
+        { role: 'done', text: `${toolSeq > 0 ? DONE_VERBS[1] : DONE_VERBS[0]} for ${secs}s` },
+        { follow: false }
+      );
       suggestionIdx = turnCount + 1;
       turnCount++;
       abort = null;
@@ -791,11 +869,12 @@ async function runSession(host) {
       // Accounting: fold the turn's usage into the session tallies, ask the
       // ledger what it settled at, and show both — tokens beside €.
       host.recordTurn(result);
-      // Persist the finished exchange for /resume. Guarded: the test host stub
-      // deliberately omits persistTurn, and the accounting below must still run.
-      if (host.persistTurn) {
-        host.persistTurn(prompt, result, abortedFlag ? 'stopped' : (result && result.error) ? 'error' : 'done');
-      }
+      // Ask the ledger what this turn settled at BEFORE persisting it. Order
+      // matters: the charge is the server's number (margin and prompt-cache
+      // discount included) and only it can answer "what did that cost". The
+      // turn used to be written first, with no charge attached, which left
+      // /cost recomputing from a local rate table that knows about neither —
+      // so the figure a user read never matched the bill they paid.
       let lastCost = null;
       try {
         const spend = await host.refreshSpend();
@@ -803,6 +882,16 @@ async function runSession(host) {
       } catch {
         /* accounting must never break a turn */
       }
+      // Persist the finished exchange for /resume. Guarded: the test host stub
+      // deliberately omits persistTurn, and the accounting below must still run.
+      if (host.persistTurn) {
+        host.persistTurn(
+          prompt,
+          result,
+          abortedFlag ? 'stopped' : (result && result.error) ? 'error' : 'done',
+          lastCost
+        );
+      }
       const usage = result && result.usage;
       const tokens = host.tokensFor ? host.tokensFor(usage) : null;
       push(

package/src/config.js

@@ -45,6 +45,10 @@ function permissionsPath() {
 
 const DEFAULT_CONFIG = {
   themeIndex: 1,   // Dark mode
+  // Cached `{ checkedAt, latest }` from the once-a-day registry check (see
+  // src/update.js). Persisted so a launch reports what the LAST run learned
+  // and never waits on the network to draw its own welcome box.
+  updateCheck: null,
   // No pinned model. This host runs on AEGIS Cloud, whose pinnable ids are the
   // server's (`/models`) — a client-side default here would have to name one,
   // and the one it named (`sonnet`) is not advertised by the platform at all:

package/src/models.js

@@ -31,12 +31,16 @@ const NO_PIN = null;
  * and the brain tier is the one id whose *cost shape* a user needs before
  * pinning it: verified live 2026-09-14, `model: "nexus-brain"` streams
  * `pool-brain: 3 workers · effort=high · tier=brain · passes=4`, i.e. four
- * billed provider calls per turn, where a provider id is one.
+ * billed provider calls per turn, where a provider id is one. That count is
+ * not fixed — the endpoint sizes the fan-out from the ask and the /effort rung
+ * (aegis1 services/pool_brain.py estimate_workers + EFFORT_MAX_WORKERS), so the
+ * label states the shape (fan-out, sized by effort) rather than a number that
+ * only held for one prompt.
  */
 const ID_NOTES = Object.freeze({
   'openai-gpt4o-mini': 'OpenAI gpt-4o-mini, pooled',
   'anthropic-haiku': 'Anthropic Haiku, pooled',
-  'nexus-brain': 'pooled brain · 3 workers + synthesis',
+  'nexus-brain': 'pooled brain · multi-call fan-out, sized by /effort',
 });
 
 /** One raw entry (string id or object) → a catalog entry, or null when unusable. */

package/src/permissions.js

@@ -29,6 +29,40 @@
 
 const RULE_RE = /^(\w+)(?:\((.*)\))?$/;
 
+/**
+ * Tool-name aliases. The shipped engine (desktop/lib/local/tools.js) names its
+ * tools readFile/writeFile/editFile/listDir/glob/grep/exec/task, while this
+ * module was ported from the reference and keyed on that CLI's names —
+ * Read/Write/Edit/Glob/Grep/Bash/Task. Those reference names are also what
+ * users write into /permissions, so both spellings must fold onto one
+ * capability. Keying on the reference's spelling alone meant subjectFor()
+ * returned '' for every tool the engine actually calls: `exec(git *)` never
+ * matched its subject, `Read(*.env)` never matched a readFile, and the
+ * multi-directory rail never fired — a permission system blind to the very
+ * tools it was meant to govern.
+ */
+const TOOL_ALIAS = {
+  exec: 'shell', Bash: 'shell',
+  readFile: 'read', Read: 'read',
+  writeFile: 'write', Write: 'write',
+  editFile: 'edit', Edit: 'edit',
+  listDir: 'list', LS: 'list',
+  glob: 'glob', Glob: 'glob',
+  grep: 'grep', Grep: 'grep',
+  task: 'task', Task: 'task',
+};
+
+/** Fold either registry's name for a tool onto the capability it names. */
+function canonTool(name) {
+  const key = String(name == null ? '' : name);
+  return TOOL_ALIAS[key] || key;
+}
+
+/** True for the engine's `exec` and the reference's `Bash` alike. */
+function isShellTool(toolName) {
+  return canonTool(toolName) === 'shell';
+}
+
 function globToRegex(pattern) {
   let re = '^';
   for (const c of pattern) {
@@ -37,23 +71,28 @@ function globToRegex(pattern) {
     else if (/[.+^${}()|[\]\\]/.test(c)) re += `\\${c}`;
     else re += c;
   }
-  return new RegExp(re + '$');
+  return new RegExp(re + "$");
 }
 
 /** The subject a rule's pattern matches against, per tool. */
 function subjectFor(toolName, args = {}) {
-  if (toolName === 'Bash') return String(args.command || '');
-  if (toolName === 'Read' || toolName === 'Write' || toolName === 'Edit') return String(args.file_path || '');
-  if (toolName === 'Glob' || toolName === 'Grep') return String(args.pattern || '');
-  return '';
+  switch (canonTool(toolName)) {
+    case 'shell': return String(args.command || '');
+    case 'read': case 'write': case 'edit': return String(args.file_path || '');
+    case 'glob': case 'grep': return String(args.pattern || '');
+    case 'list': return String(args.path || '');
+    default: return '';
+  }
 }
 
 function matchRule(rule, toolName, subject) {
   const m = RULE_RE.exec(String(rule || '').trim());
   if (!m) return false;
   const [, tool, pattern] = m;
-  if (tool !== toolName) return false;
-  if (pattern === undefined) return true; // bare "Bash" matches every call
+  // A rule spelled with the reference's name governs the engine's tool and
+  // vice versa: `Bash(git *)` and `exec(git *)` are one rule, not two.
+  if (canonTool(tool) !== canonTool(toolName)) return false;
+  if (pattern === undefined) return true; // bare "Bash"/"exec" matches every call
   try { return globToRegex(pattern).test(subject); } catch { return false; }
 }
 
@@ -90,13 +129,17 @@ function evalPermission(toolName, args, rules = {}) {
   const subject = subjectFor(toolName, args);
   if (matchesAny(rules.deny, toolName, subject)) return 'deny';
   if (matchesAny(rules.allow, toolName, subject)) return 'allow';
-  if (toolName === 'Bash' && isMultiDirCommand(args && args.command)) return 'ask';
+  if (isShellTool(toolName) && isMultiDirCommand(args && args.command)) return 'ask';
   if (matchesAny(rules.ask, toolName, subject)) return 'ask';
   if (rules.explicitAsk && rules.defaultMode === 'ask') return 'ask';
   return 'allow';
 }
 
 module.exports = {
+  canonTool,
+  isShellTool,
+  subjectFor,
+  matchRule,
   isMultiDirCommand,
   evalPermission,
 };

package/src/render.js

@@ -279,11 +279,14 @@ function renderMeta(ctx, meta = {}, width = 80) {
   const bits = [];
   if (meta.model) bits.push(`${t.blue}${meta.model}${RESET}`);
   if (meta.tokens != null) bits.push(`${t.white}${fmtTokens(meta.tokens)} tok${RESET}`);
-  if (meta.usage) {
-    const { input, output } = meta.usage;
-    if (Number.isFinite(input) || Number.isFinite(output)) {
-      bits.push(`${t.gray}${fmtTokens(input || 0)}/${fmtTokens(output || 0)}${RESET}`);
-    }
+  // The producer (chatflow.js's accounting row) pushes the split flat, as
+  // `input`/`output` — reading it as `meta.usage.input` here meant the pair was
+  // never printed on this path even though the docstring above promises it.
+  // Both shapes are accepted: `usage` is what the desktop's renderer hands over.
+  const split = meta.usage && typeof meta.usage === 'object' ? meta.usage : meta;
+  const { input, output } = split;
+  if (Number.isFinite(input) || Number.isFinite(output)) {
+    bits.push(`${t.gray}${fmtTokens(input || 0)}/${fmtTokens(output || 0)}${RESET}`);
   }
   if (meta.eur != null) bits.push(`${meta.eur > 0 ? t.coral : t.green}${fmtEur(meta.eur)}${RESET}`);
   if (meta.ms != null) bits.push(`${t.gray}${fmtElapsed(meta.ms)}${RESET}`);

package/src/screens.js

@@ -35,7 +35,8 @@ const { C, BOLD, BOLD_OFF, GLYPH, THEME_TABLE, themeOf } = require('./theme.js')
 const { welcomeArtParts } = require('./art.js');
 const { renderDiffPreview } = require('./markdown.js');
 const render = require('./render.js');
-const { updateConfig, configExists } = require('./config.js');
+const { updateConfig, configExists, loadConfig } = require('./config.js');
+const { updateNotice, updateLine } = require('./update.js');
 const credentials = require('./credentials.js');
 
 const VERSION = require('../package.json').version;
@@ -251,6 +252,22 @@ function welcomeLines(ctx, cols, rows, firstRun = true) {
   lines.push([span(t.gold, '━' + '─'.repeat(Math.max(0, cols - 2)) + '━')]);
   lines.push([span('', '')]);
 
+  // A newer release, if the last run found one. Reads cache only — the
+  // refresh it may kick off lands for the NEXT launch, so drawing this box
+  // never waits on the registry.
+  let updateMsg = null;
+  try {
+    const cfg = loadConfig();
+    const notice = updateNotice({
+      current: VERSION,
+      cache: cfg.updateCheck,
+      save: (v) => { try { updateConfig({ updateCheck: v }); } catch { /* not fatal */ } },
+    });
+    updateMsg = updateLine({ current: VERSION, ...notice });
+  } catch {
+    // An update notice is never worth failing a launch over.
+  }
+
   const parts = welcomeArtParts(cols);
   if (cols >= parts.width + 2) {
     const leftPad = Math.max(0, Math.floor((cols - parts.width) / 2));
@@ -260,6 +277,10 @@ function welcomeLines(ctx, cols, rows, firstRun = true) {
   } else {
     lines.push(centered(`${PRODUCT}`, cols, t.gold + BOLD));
   }
+  if (updateMsg) {
+    lines.push([span('', '')]);
+    lines.push(centered(updateMsg, cols, t.gold));
+  }
   lines.push([span('', '')]);
 
   const title = firstRun ? `Welcome to ${PRODUCT}` : 'Welcome back!';

package/src/update.js

@@ -0,0 +1,137 @@
+/**
+ * "There is a newer version" — the notice this CLI never had.
+ *
+ * Checked on 2026-09-15: there was no update check anywhere in the client, so
+ * a user learned about a release only by guessing to run
+ * `npm i -g aegiscode@latest`. Publishing therefore reached almost nobody, and
+ * the installed base drifted months behind the registry.
+ *
+ * Three rules, because an update check is a background nicety that must never
+ * become a liability:
+ *   · it never blocks — the caller gets a cached answer immediately and the
+ *     network call settles whenever it settles;
+ *   · it never throws — offline, proxied, rate-limited or garbage JSON all
+ *     mean "no notice", not a broken CLI;
+ *   · it never nags — one check a day, cached, and nothing printed when the
+ *     user is already current.
+ */
+
+const https = require('node:https');
+
+const REGISTRY = 'https://registry.npmjs.org';
+const PKG = 'aegiscode';
+/** One check a day. A CLI that pings the registry every launch is spyware. */
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** The registry is not on the critical path; give up quickly and silently. */
+const TIMEOUT_MS = 2500;
+
+/** Compare two semver-ish strings. Returns true when `latest` is newer. */
+function isNewer(latest, current) {
+  const parse = (v) =>
+    String(v || '')
+      .trim()
+      .replace(/^v/, '')
+      .split('-')[0] // a prerelease never counts as newer than its release
+      .split('.')
+      .map((n) => Number.parseInt(n, 10) || 0);
+  const a = parse(latest);
+  const b = parse(current);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] || 0;
+    const y = b[i] || 0;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+
+/** Fetch the registry's `latest` dist-tag. Resolves null on any failure. */
+function fetchLatest({ pkg = PKG, timeoutMs = TIMEOUT_MS } = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (v) => {
+      if (!settled) {
+        settled = true;
+        resolve(v);
+      }
+    };
+    try {
+      // The abbreviated metadata document: a few KB instead of the full
+      // packument, which for a package with this many releases is megabytes.
+      const req = https.get(
+        `${REGISTRY}/${pkg}`,
+        { headers: { accept: 'application/vnd.npm.install-v1+json' }, timeout: timeoutMs },
+        (res) => {
+          if (res.statusCode !== 200) {
+            res.resume();
+            return done(null);
+          }
+          let body = '';
+          res.setEncoding('utf8');
+          res.on('data', (c) => {
+            body += c;
+            if (body.length > 2_000_000) {
+              req.destroy();
+              done(null);
+            }
+          });
+          res.on('end', () => {
+            try {
+              const tags = JSON.parse(body)['dist-tags'];
+              done((tags && tags.latest) || null);
+            } catch {
+              done(null);
+            }
+          });
+        }
+      );
+      req.on('timeout', () => {
+        req.destroy();
+        done(null);
+      });
+      req.on('error', () => done(null));
+    } catch {
+      done(null);
+    }
+  });
+}
+
+/**
+ * The notice to show, from cache. Never waits on the network.
+ *
+ * `cache` is the persisted `{ checkedAt, latest }` blob; `save` persists a new
+ * one. Returns `{ latest, behind }`, and kicks off a refresh in the background
+ * when the cache is stale.
+ */
+function updateNotice({
+  current,
+  cache,
+  save,
+  now = Date.now(),
+  fetchImpl = fetchLatest,
+  intervalMs = CHECK_INTERVAL_MS,
+} = {}) {
+  const c = cache || {};
+  const fresh = typeof c.checkedAt === 'number' && now - c.checkedAt < intervalMs;
+
+  if (!fresh) {
+    // Fire and forget: this run reports on what was already known, and the
+    // answer lands for the next one. A first run therefore never shows a
+    // notice, which is correct — it has nothing to compare against yet.
+    Promise.resolve(fetchImpl())
+      .then((latest) => {
+        if (latest && typeof save === 'function') save({ checkedAt: now, latest });
+      })
+      .catch(() => {});
+  }
+
+  const latest = c.latest || null;
+  return { latest, behind: !!(latest && isNewer(latest, current)) };
+}
+
+/** One line for the welcome box, or null when there is nothing to say. */
+function updateLine({ current, latest, behind }) {
+  if (!behind) return null;
+  return `Update available: ${current} → ${latest}   run: npm i -g ${PKG}@latest`;
+}
+
+module.exports = { isNewer, fetchLatest, updateNotice, updateLine, PKG, CHECK_INTERVAL_MS };

package/vendor/client/aegis.js

@@ -465,6 +465,9 @@ function createClient(opts = {}) {
     const decoder = new TextDecoder();
     let buffer = '';
     let fullText = '';
+    // Mirrors fullText for the reasoning channel so a reasoning SNAPSHOT is
+    // deduplicated the same way a content snapshot is.
+    let reasoningText = '';
     let resultModel = body.model;
     let usage = null;
     let sseError = '';
@@ -489,13 +492,26 @@ function createClient(opts = {}) {
     // default Nexus turn (brain model id, checkbox off) dying at 60s — with
     // the server already past its own fan-out deadline and every worker
     // billed. See idleBudgetFor().
+    // The budget is measured from the last real `data:` frame, not from the
+    // last read. SSE keep-alive comments (": keep-alive") are transport
+    // framing, and a stalled upstream can emit them forever: a watchdog armed
+    // per read() is reset by every one of them and so never fires, which is
+    // exactly the hang this guard exists to prevent. Only a parsed payload
+    // moves `lastPayloadAt` below.
     const idleMs = idleBudgetFor(res, idleTimeoutMs);
+    let lastPayloadAt = Date.now();
+    let keepAlives = 0;
     async function readWithIdleTimeout() {
       let timer;
+      const remaining = Math.max(0, idleMs - (Date.now() - lastPayloadAt));
       const timeout = new Promise((_, reject) => {
         timer = setTimeout(() => {
-          reject(new Error(`stream stalled - no data for ${idleMs / 1000}s`));
-        }, idleMs);
+          reject(new Error(
+            keepAlives > 0
+              ? `stream stalled - only keep-alives for ${idleMs / 1000}s`
+              : `stream stalled - no data for ${idleMs / 1000}s`
+          ));
+        }, remaining);
       });
       try {
         return await Promise.race([reader.read(), timeout]);
@@ -520,7 +536,11 @@ function createClient(opts = {}) {
 
       for (const rawLine of lines) {
         const line = rawLine.trim();
-        if (!line.startsWith('data:')) continue;
+        if (!line.startsWith('data:')) {
+          if (line.startsWith(':')) keepAlives++;
+          continue;
+        }
+        lastPayloadAt = Date.now(); // a real frame: the stream is still speaking
         const payload = line.slice(5).trim();
         if (!payload || payload === '[DONE]') continue;
         let json;
@@ -548,24 +568,48 @@ function createClient(opts = {}) {
         // synthesis pass writes the visible answer. Deliberately kept out of
         // `fullText` — deliberation is not an answer, and counting it would
         // make a no-answer turn look answered to every caller's empty-check.
-        const reasoning =
-          (choice &&
-            ((choice.delta && choice.delta.reasoning_content) ||
-              (choice.message && choice.message.reasoning_content))) ||
-          '';
-        if (reasoning) {
-          if (typeof onReasoning === 'function') onReasoning(reasoning);
-          else onStream({ reasoning });
-        }
-        const delta =
-          (choice &&
-            ((choice.delta && choice.delta.content) ||
-              (choice.message && choice.message.content))) ||
-          '';
-        if (delta) {
-          fullText += delta;
-          onStream({ delta });
-        }
+        // `delta.*` is an INCREMENT; `message.*` is a SNAPSHOT of the whole
+        // message so far. Collapsing them with `||` made a stream that ends
+        // with a message snapshot append the entire answer a second time —
+        // the duplicated text in the CLI. They are merged here through one
+        // helper that emits only what the caller has not already seen.
+        const advance = (increment, snapshot, seen, emit) => {
+          if (typeof increment === 'string' && increment) {
+            emit(increment);
+            return seen + increment;
+          }
+          if (typeof snapshot === 'string' && snapshot) {
+            if (!seen) { emit(snapshot); return snapshot; }
+            // The usual shape: the snapshot restates everything streamed so
+            // far, so only the tail is new.
+            if (snapshot.startsWith(seen)) {
+              const tail = snapshot.slice(seen.length);
+              if (tail) emit(tail);
+              return snapshot;
+            }
+            // Disjoint from what was already shown — cannot be reconciled, and
+            // appending it would duplicate. Keep what the caller has seen.
+            return seen;
+          }
+          return seen;
+        };
+
+        reasoningText = advance(
+          choice && choice.delta && choice.delta.reasoning_content,
+          choice && choice.message && choice.message.reasoning_content,
+          reasoningText,
+          (chunk) => {
+            if (typeof onReasoning === 'function') onReasoning(chunk);
+            else onStream({ reasoning: chunk });
+          }
+        );
+
+        fullText = advance(
+          choice && choice.delta && choice.delta.content,
+          choice && choice.message && choice.message.content,
+          fullText,
+          (chunk) => onStream({ delta: chunk })
+        );
         const fragments =
           (choice && choice.delta && choice.delta.tool_calls) ||
           (choice && choice.message && choice.message.tool_calls);

package/vendor/client/session-store.js

@@ -104,6 +104,98 @@ function atomicWrite(file, data) {
   } catch {}
 }
 
+/** How long a lock may be held before another writer treats it as abandoned. */
+const LOCK_STALE_MS = 2000;
+/** Total time a writer will wait for the lock before proceeding unlocked. */
+const LOCK_WAIT_MS = 500;
+
+function lockFile(dir) {
+  return `${storeFile(dir)}.lock`;
+}
+
+/**
+ * Best-effort advisory lock around the read-modify-write in `mutate()`.
+ *
+ * A private store owned by one process did not need this. A *shared* one does:
+ * the desktop app and a terminal session are two long-lived processes that both
+ * rewrite this file wholesale, and interleaved read-modify-write would drop
+ * whichever turn lost the race. The lock is deliberately soft — a crash must
+ * not wedge every future write, so a lock older than LOCK_STALE_MS is stolen,
+ * and a writer that cannot get it in LOCK_WAIT_MS proceeds anyway (losing at
+ * worst the same race that exists today, rather than refusing to save).
+ *
+ * @returns {boolean} whether the lock was acquired
+ */
+function acquireLock(dir) {
+  const file = lockFile(dir);
+  // The lock is taken *before* the write that used to create the directory, so
+  // this is now the first thing to touch it — a first run (or a fresh
+  // AEGISCODE_HOME) would otherwise spin here forever waiting on a lock it can
+  // never create.
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+  } catch {
+    return false;
+  }
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  // Bounded, so no combination of "lock vanished" / "lock unreadable" can spin
+  // this loop: a writer that cannot decide always proceeds unlocked instead.
+  const MAX_ATTEMPTS = 200;
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    try {
+      const fd = fs.openSync(file, 'wx');
+      fs.writeSync(fd, String(process.pid));
+      fs.closeSync(fd);
+      return true;
+    } catch {
+      let age = null;
+      try {
+        age = Date.now() - fs.statSync(file).mtimeMs;
+      } catch {
+        // Released between the open and the stat — try immediately.
+        continue;
+      }
+      if (age > LOCK_STALE_MS) {
+        try {
+          fs.unlinkSync(file);
+        } catch {}
+        continue;
+      }
+      if (Date.now() >= deadline) return false;
+      // Busy-wait: the critical section is a few hundred microseconds of
+      // stringify + rename, so sleeping the event loop would cost more than it
+      // saves, and this path is not on the streaming critical path.
+      const until = Date.now() + 5;
+      while (Date.now() < until) {
+        /* spin a few ms */
+      }
+    }
+  }
+  return false;
+}
+
+function releaseLock(dir) {
+  try {
+    fs.unlinkSync(lockFile(dir));
+  } catch {}
+}
+
+/**
+ * Read-modify-write the whole store under the lock. Every mutation goes through
+ * here so the locking is one behaviour, not a thing each caller must remember.
+ */
+function mutate(dir, mutator) {
+  const locked = acquireLock(dir);
+  try {
+    const sessions = load(dir);
+    const result = mutator(sessions);
+    save(dir, sessions);
+    return result;
+  } finally {
+    if (locked) releaseLock(dir);
+  }
+}
+
 function save(dir, sessions) {
   atomicWrite(storeFile(dir), sessions);
 }
@@ -124,29 +216,29 @@ function trimMessages(messages) {
 function upsertSession(dir, session) {
   const id = session && session.id;
   if (!id) throw new Error('session.id is required');
-  const sessions = load(dir);
-  const prev = sessions[id] || { messages: [] };
-  sessions[id] = { ...prev, ...session, id, version: STORE_VERSION };
-  if (session.pending !== false) sessions[id].pending = true;
-  if (!sessions[id].updatedAt) sessions[id].updatedAt = Date.now();
-  sessions[id].seq = nextSeq(sessions);
-  save(dir, sessions);
-  return sessions[id];
+  return mutate(dir, (sessions) => {
+    const prev = sessions[id] || { messages: [] };
+    sessions[id] = { ...prev, ...session, id, version: STORE_VERSION };
+    if (session.pending !== false) sessions[id].pending = true;
+    if (!sessions[id].updatedAt) sessions[id].updatedAt = Date.now();
+    sessions[id].seq = nextSeq(sessions);
+    return sessions[id];
+  });
 }
 
 /** Append one message to a session (crash-safe). */
 function appendMessage(dir, sessionId, message) {
   if (!sessionId) throw new Error('sessionId is required');
-  const sessions = load(dir);
-  const session = sessions[sessionId] || { id: sessionId, messages: [] };
-  const messages = Array.isArray(session.messages) ? session.messages : [];
-  session.messages = trimMessages(messages.concat(message));
-  session.updatedAt = Date.now();
-  session.pending = true;
-  session.seq = nextSeq(sessions);
-  sessions[sessionId] = session;
-  save(dir, sessions);
-  return session;
+  return mutate(dir, (sessions) => {
+    const session = sessions[sessionId] || { id: sessionId, messages: [] };
+    const messages = Array.isArray(session.messages) ? session.messages : [];
+    session.messages = trimMessages(messages.concat(message));
+    session.updatedAt = Date.now();
+    session.pending = true;
+    session.seq = nextSeq(sessions);
+    sessions[sessionId] = session;
+    return session;
+  });
 }
 
 /**
@@ -166,34 +258,34 @@ function appendMessage(dir, sessionId, message) {
 function recordExchange(dir, exchange) {
   const e = exchange || {};
   if (!e.sessionId) return null;
-  const sessions = load(dir);
   const id = e.sessionId;
-  const session = sessions[id] || { id, messages: [] };
-  const messages = Array.isArray(session.messages) ? session.messages : [];
-  const ts = e.ts || new Date().toISOString();
-  const userMessage = { role: 'user', content: e.prompt == null ? '' : String(e.prompt), ts };
-  const assistantMessage = { role: 'assistant', content: e.reply == null ? '' : String(e.reply), ts };
-  if (e.tokens) assistantMessage.tokens = e.tokens;
-  if (typeof e.costUsd === 'number') assistantMessage.costUsd = e.costUsd;
-  if (e.status) assistantMessage.status = e.status;
-  if (e.origin) {
-    userMessage.origin = e.origin;
-    assistantMessage.origin = e.origin;
-  }
-  session.messages = trimMessages(messages.concat([userMessage, assistantMessage]));
-  session.title = session.title || String(e.prompt || '').slice(0, 60);
-  if (e.cwd) session.cwd = e.cwd;
-  session.origin = e.origin || session.origin || 'unknown';
-  session.updatedAt = Date.now();
-  // Explicit, not merely "leave it unset": `listPending` treats an absent flag
-  // as pending (sessions predating the field default to queued), so an
-  // undefined here would quietly enrol every terminal session in the desktop's
-  // push queue — the exact thing the `pending: false` default is for.
-  session.pending = e.pending === true ? true : false;
-  session.seq = nextSeq(sessions);
-  sessions[id] = session;
-  save(dir, sessions);
-  return session;
+  return mutate(dir, (sessions) => {
+    const session = sessions[id] || { id, messages: [] };
+    const messages = Array.isArray(session.messages) ? session.messages : [];
+    const ts = e.ts || new Date().toISOString();
+    const userMessage = { role: 'user', content: e.prompt == null ? '' : String(e.prompt), ts };
+    const assistantMessage = { role: 'assistant', content: e.reply == null ? '' : String(e.reply), ts };
+    if (e.tokens) assistantMessage.tokens = e.tokens;
+    if (typeof e.costUsd === 'number') assistantMessage.costUsd = e.costUsd;
+    if (e.status) assistantMessage.status = e.status;
+    if (e.origin) {
+      userMessage.origin = e.origin;
+      assistantMessage.origin = e.origin;
+    }
+    session.messages = trimMessages(messages.concat([userMessage, assistantMessage]));
+    session.title = session.title || String(e.prompt || '').slice(0, 60);
+    if (e.cwd) session.cwd = e.cwd;
+    session.origin = e.origin || session.origin || 'unknown';
+    session.updatedAt = Date.now();
+    // Explicit, not merely "leave it unset": `listPending` treats an absent flag
+    // as pending (sessions predating the field default to queued), so an
+    // undefined here would quietly enrol every terminal session in the desktop's
+    // push queue — the exact thing the `pending: false` default is for.
+    session.pending = e.pending === true ? true : false;
+    session.seq = nextSeq(sessions);
+    sessions[id] = session;
+    return session;
+  });
 }
 
 function listSessions(dir) {
@@ -212,37 +304,35 @@ function getSession(dir, id) {
 }
 
 function deleteSession(dir, id) {
-  const sessions = load(dir);
-  delete sessions[id];
-  save(dir, sessions);
-  return { ok: true };
+  return mutate(dir, (sessions) => {
+    delete sessions[id];
+    return { ok: true };
+  });
 }
 
 /** Clear the pending flag after a successful cloud push. `remote.remoteId`,
  *  when the server assigns its own conversation id, is stashed alongside. */
 function markSynced(dir, id, remote) {
-  const sessions = load(dir);
-  const session = sessions[id];
-  if (!session) return null;
-  session.pending = false;
-  session.lastSyncedAt = Date.now();
-  if (remote && remote.remoteId) session.remoteId = remote.remoteId;
-  session.seq = nextSeq(sessions);
-  sessions[id] = session;
-  save(dir, sessions);
-  return session;
+  return mutate(dir, (sessions) => {
+    const session = sessions[id];
+    if (!session) return null;
+    session.pending = false;
+    session.lastSyncedAt = Date.now();
+    if (remote && remote.remoteId) session.remoteId = remote.remoteId;
+    session.seq = nextSeq(sessions);
+    return session;
+  });
 }
 
 /** Force a session back into the retry queue (e.g. a push that partially failed). */
 function markPending(dir, id) {
-  const sessions = load(dir);
-  const session = sessions[id];
-  if (!session) return null;
-  session.pending = true;
-  session.seq = nextSeq(sessions);
-  sessions[id] = session;
-  save(dir, sessions);
-  return session;
+  return mutate(dir, (sessions) => {
+    const session = sessions[id];
+    if (!session) return null;
+    session.pending = true;
+    session.seq = nextSeq(sessions);
+    return session;
+  });
 }
 
 /** Sessions with local content the cloud hasn't confirmed yet (including
@@ -259,32 +349,33 @@ function listPending(dir) {
  */
 function mergeRemoteSessions(dir, remoteSessions) {
   const list = Array.isArray(remoteSessions) ? remoteSessions : [];
-  const sessions = load(dir);
-  let merged = 0;
-  for (const remote of list) {
-    const id = remote && (remote.session_id || remote.id);
-    if (!id) continue;
-    const local = sessions[id];
-    const remoteUpdatedAt = toEpochMs(remote.updated_at ?? remote.updatedAt);
-    if (local && (local.pending || (local.updatedAt || 0) >= remoteUpdatedAt)) {
-      continue;
+  if (!list.length) return 0;
+  return mutate(dir, (sessions) => {
+    let merged = 0;
+    for (const remote of list) {
+      const id = remote && (remote.session_id || remote.id);
+      if (!id) continue;
+      const local = sessions[id];
+      const remoteUpdatedAt = toEpochMs(remote.updated_at ?? remote.updatedAt);
+      if (local && (local.pending || (local.updatedAt || 0) >= remoteUpdatedAt)) {
+        continue;
+      }
+      sessions[id] = {
+        id,
+        title: remote.title || (local && local.title) || '',
+        messages: Array.isArray(remote.messages) ? remote.messages : [],
+        updatedAt: remoteUpdatedAt || Date.now(),
+        pending: false,
+        lastSyncedAt: Date.now(),
+        remoteId: remote.session_id || remote.id,
+        origin: remote.source || (local && local.origin) || 'cloud',
+        version: STORE_VERSION,
+      };
+      sessions[id].seq = nextSeq(sessions);
+      merged += 1;
     }
-    sessions[id] = {
-      id,
-      title: remote.title || (local && local.title) || '',
-      messages: Array.isArray(remote.messages) ? remote.messages : [],
-      updatedAt: remoteUpdatedAt || Date.now(),
-      pending: false,
-      lastSyncedAt: Date.now(),
-      remoteId: remote.session_id || remote.id,
-      origin: remote.source || (local && local.origin) || 'cloud',
-      version: STORE_VERSION,
-    };
-    sessions[id].seq = nextSeq(sessions);
-    merged += 1;
-  }
-  if (merged) save(dir, sessions);
-  return merged;
+    return merged;
+  });
 }
 
 /**
@@ -355,14 +446,16 @@ function adopt(dir, fromDir) {
   if (listSessions(dir).length) {
     return { adopted: false, sessions: 0, from, reason: 'store already has sessions' };
   }
-  const next = { ...legacy, __seq: legacy.__seq || 0 };
-  for (const s of incoming) {
-    // Adopted sessions keep their own history; they are already local content.
-    s.seq = nextSeq(next);
-    s.adoptedFrom = from;
-  }
-  next.version = STORE_VERSION;
-  save(dir, next);
+  mutate(dir, (sessions) => {
+    for (const s of incoming) {
+      // Adopted sessions keep their own history; they are already local content.
+      sessions[s.id] = { ...s, adoptedFrom: from, version: STORE_VERSION };
+      sessions[s.id].seq = nextSeq(sessions);
+    }
+    sessions.__seq = Math.max(sessions.__seq || 0, legacy.__seq || 0);
+    sessions.version = STORE_VERSION;
+    return null;
+  });
   return { adopted: true, sessions: incoming.length, from };
 }
 
@@ -397,6 +490,9 @@ module.exports = {
   MAX_MESSAGES_PER_SESSION,
   storeDir,
   storeFile,
+  lockFile,
+  LOCK_STALE_MS,
+  LOCK_WAIT_MS,
   toEpochMs,
   load,
   save,

package/vendor/desktop/lib/local/engine.js

@@ -109,18 +109,38 @@ const EFFORT_TOKEN_BUDGET = { low: 8192, medium: 16384, high: 32768 };
 const AUTONOMOUS_IDLE_TIMEOUT_MS = 15 * 60_000;
 
 /**
- * Only ever raises a too-low budget for a DeepSeek reasoning model — never
- * lowers whatever the caller (renderer dropdown, or "adaptive" ceiling)
- * already asked for. Everything else (non-DeepSeek models, non-reasoning
- * DeepSeek ids like deepseek-chat) passes through untouched. Effort defaults
- * to 'high' since custom endpoints have no effort selector of their own
- * (that UI is aegis-class/autonomous-only) — matching aegiscodex-dev's own
- * default effort.
+ * The budget a DeepSeek reasoning model runs on, resolved from EXACTLY ONE
+ * authority per call.
+ *
+ * A caller-stated number IS the budget, and is returned verbatim. For the
+ * non-pooled classes the renderer's max-tokens dropdown is the only budget
+ * control on offer — updateBudgetControls hides the effort row for them — so
+ * silently raising that number to an effort rung is precisely what made the
+ * figure beside the dropdown untrustworthy. The old form was
+ * `Math.max(stated, EFFORT_TOKEN_BUDGET[eff])`, which could only ever raise a
+ * deliberate cap: a caller asking for 1024 ran on 32768, and the number the
+ * UI displayed was never the number the call used.
+ *
+ * The effort rung is the DEFAULT, consulted only when no number was stated at
+ * all (the pooled class, which the renderer sends `effort` for and which the
+ * server sizes itself). This is the same rule doubledBudget() follows for its
+ * truncation retry: a stated cap is never overridden, by a rung or an order of
+ * magnitude.
+ *
+ * Truncated and empty turns are handled where they belong — the doubled-budget
+ * retry plus emptyTurnError — rather than by inflating the caller's ceiling up
+ * front. Escalating on a demonstrated empty turn is strictly cheaper than
+ * pre-emptively granting the top rung to every reasoning call.
+ *
+ * Everything else (non-DeepSeek models, non-reasoning DeepSeek ids like
+ * deepseek-chat) passes through untouched.
  */
-function deepseekReasoningFloor(model, maxTokens, effort) {
+function reasoningBudget(model, maxTokens, effort) {
   if (!DEEPSEEK_REASONING_MODEL_RE.test(String(model || ''))) return maxTokens;
+  const stated = Number(maxTokens);
+  if (Number.isFinite(stated) && stated > 0) return stated;
   const eff = effort === 'low' || effort === 'medium' ? effort : 'high';
-  return Math.max(Number(maxTokens) || 0, EFFORT_TOKEN_BUDGET[eff]);
+  return EFFORT_TOKEN_BUDGET[eff];
 }
 
 /** Relay model entries arrive as ids or objects; keep only real model ids. */
@@ -545,7 +565,24 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
         messages: opts.messages,
         model: opts.model,
         mode: opts.mode,
-        maxTokens: opts.maxTokens,
+        // Only a cap the caller STATED travels; an effort-derived one does not.
+        // The server derives its own budget from `effort` (aegis1 pass_budgets
+        // splits its ladder across workers + synthesis), so forwarding the
+        // derived number states one decision twice — and the copies had already
+        // drifted: 974adc5 doubled aegis1's ladder while this side stood still,
+        // leaving the client capping below the budget it displayed. The cap was
+        // never the one the renderer showed either (updateBudgetControls hides
+        // the max-tokens dropdown for the pooled class). Omitting the field is
+        // what tells aegis1 "no cap stated — let effort decide", the same
+        // contract aegiscodex-dev sends.
+        //
+        // A cap the caller DID state is a different thing, and dropping it was
+        // a bug: aegis1 reads a body max_tokens as a ceiling over its ladder,
+        // so omitting it does not bound the call — it grants the full top rung
+        // instead. A deliberate 4096 would have run at 32768, which is the same
+        // "only ever raise the caller's ceiling" failure the old
+        // Math.max(Number(maxTokens) || 0, EFFORT_TOKEN_BUDGET[eff]) had.
+        maxTokens: opts.statedMaxTokens,
         stream: opts.stream !== false,
         // The pooled (Nexus) brain is streamed, and an OpenAI-compatible SSE
         // stream reports no token usage unless asked. Without this the Aegis
@@ -638,7 +675,16 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
   async function chat(payload, onDelta) {
     const cls = payload && payload.class;
     const model = payload && payload.model;
-    const maxTokens = deepseekReasoningFloor(model, payload && payload.maxTokens, payload && payload.effort);
+    const maxTokens = reasoningBudget(model, payload && payload.maxTokens, payload && payload.effort);
+    // The caller's OWN number, kept apart from `maxTokens` above. That one
+    // collapses two different facts into a single value — "the caller stated
+    // 4096" and "effort implies 32768" — and the pooled path must treat them
+    // differently. A stated cap is a liability ceiling the server honours
+    // downward (aegis1 pass_budgets: total = min(ladder, max_tokens x passes));
+    // an effort-derived one is the server's own arithmetic stated twice, and
+    // sending it is how the two copies came to disagree. So the pooled call
+    // forwards only what the caller actually asked for.
+    const statedMaxTokens = Number(payload && payload.maxTokens) > 0 ? Number(payload.maxTokens) : undefined;
     // "Work autonomously" — routes this call through aegis1's pool_brain
     // worker fan-out (services/pool_brain.py: N reasoning workers + a
     // synthesis pass) instead of a single provider call. UI-gated to the
@@ -710,7 +756,7 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
       }
 
       const base = {
-        cls, model, mode: payload && payload.mode, maxTokens, autonomous, sessionId, signal, onDelta, cfg, apiKey, toolChoice,
+        cls, model, mode: payload && payload.mode, maxTokens, statedMaxTokens, autonomous, sessionId, signal, onDelta, cfg, apiKey, toolChoice,
         effort: payload && payload.effort,
         workers: payload && payload.workers,
         onReasoning,
@@ -741,6 +787,26 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
       let truncationRetried = false;
       let synthesisDone = false;
 
+      // Round cap — the bound aegiscodex-dev has had all along and this engine
+      // did not. Removing the old fixed cap (12) was right in spirit and wrong
+      // in effect: it left the turn with NO horizon, and on 2026-09-15 the
+      // question "can you check the plan" ran ~70 rounds, grew the context
+      // from 2,260 to 116,011 tokens, cost about EUR 2, and spent those rounds
+      // writing 400 lines of unrequested code into the source tree. Each round
+      // re-sends the whole conversation, so an unbounded loop gets more
+      // expensive the longer it runs.
+      //
+      // The numbers match aegiscodex-dev's (src/autonomous.js) so both clients
+      // behave the same: 24 rounds for a chat turn, 40 for an autonomous one.
+      // Env-overridable for a deliberately long job.
+      const maxRounds = (() => {
+        const name = autonomous ? 'AEGIS_AUTONOMOUS_MAX_ROUNDS' : 'AEGIS_CHAT_MAX_ROUNDS';
+        const raw = Number.parseInt(process.env[name] || '', 10);
+        if (Number.isFinite(raw) && raw > 0) return raw;
+        return autonomous ? 40 : 24;
+      })();
+      let round = 0;
+
       // Token accounting for the whole TURN, not just its last round. An
       // agentic turn makes one provider call per tool round, and returning only
       // the final round's `usage` (what this did) reported a fraction of what
@@ -789,6 +855,24 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
       };
 
       for (;;) {
+        // Stop and SAY so. A turn that reaches its horizon has usually done
+        // real work; ending silently would paint an empty answer over it,
+        // which is the same "(empty response)" failure the guards below exist
+        // to prevent.
+        if (round >= maxRounds) {
+          const note =
+            `[stopped at ${maxRounds} tool rounds` +
+            `${turnUsage.total_tokens ? `, ${turnUsage.total_tokens.toLocaleString()} tokens` : ''}` +
+            `. Ask again to continue, or raise ` +
+            `${autonomous ? 'AEGIS_AUTONOMOUS_MAX_ROUNDS' : 'AEGIS_CHAT_MAX_ROUNDS'}.]`;
+          if (rootOnDelta) rootOnDelta({ delta: `\n\n${note}` });
+          return withTurnUsage({
+            model: base.model,
+            choices: [{ message: { content: note }, finish_reason: 'length' }],
+            stoppedOnRounds: true,
+          });
+        }
+        round += 1;
         const opts = { ...base, system, messages: history, prompt, tools: toolSchemas };
         let res;
         try {
@@ -834,6 +918,12 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
             ...opts,
             singlePass: true,
             maxTokens: doubledBudget(opts.maxTokens),
+            // Doubling applies to the pooled path only when the caller stated a
+            // number. With none stated, the server's effort ladder IS the
+            // budget, and sending doubledBudget's 8192 floor would *lower* it
+            // (aegis1 reads max_tokens as a ceiling over the ladder) — a
+            // "double the budget" retry that halves it at high effort.
+            statedMaxTokens: opts.statedMaxTokens ? doubledBudget(opts.statedMaxTokens) : undefined,
           });
           addUsage(res);
         }