aegiscode 6.3.1 → 6.3.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegiscode",
   "productName": "AEGIS Code",
-  "version": "6.3.1",
+  "version": "6.3.2",
   "description": "aegiscode — 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

@@ -87,7 +87,11 @@ function createApp(options = {}) {
   const commandCtx = {
     light: opts.light,
     model: opts.model,
-    effort: 'high',
+    // `null` = "auto": send no effort, so the server sizes the turn from the
+    // ask. This is the *budget* control on the pooled class (aegis1 sizes the
+    // token ladder from it), which is why it is not defaulted to a rung here —
+    // pinning one would make every turn cost what that rung grants.
+    effort: null,
     thinking: false,
     themeIndex: opts.light ? 2 : 1,
     vim: false,
@@ -371,6 +375,14 @@ function createApp(options = {}) {
           model: commandCtx.model || undefined,
           system: opts.system,
           maxTokens: opts.maxTokens,
+          // `effort` is the pooled budget control, and it travels on every turn
+          // — this host only ever runs the 'aegis' class, whose calls are sized
+          // server-side from it (aegis1 services/pool_brain.py). It used to be
+          // held in the session state and rendered in the status line without
+          // ever reaching the wire, so /effort changed the display and nothing
+          // about what the turn cost. `null` (auto) is omitted so the server
+          // infers the rung from the ask.
+          effort: commandCtx.effort || undefined,
           // false asks the engine for the buffered (non-stream) wire form, so
           // `--no-stream` and piped runs get a single body rather than SSE.
           stream: commandCtx.stream !== false,
@@ -1073,6 +1085,8 @@ function createApp(options = {}) {
       return;
     }
     if (!opts.model && cfg.model) commandCtx.model = cfg.model;
+    // `null` in the config is "auto" and is deliberately not assigned over the
+    // default — there is nothing to restore, because nothing is pinned.
     if (cfg.effort) commandCtx.effort = cfg.effort;
     if (typeof cfg.vim === 'boolean') commandCtx.vim = cfg.vim;
     if (cfg.lastRecap) commandCtx.lastRecap = cfg.lastRecap;

package/src/chatflow.js

@@ -164,7 +164,7 @@ const separatorLine = (cols, ctx) => [span(themeOf(ctx).dim, '─'.repeat(cols))
 /** The idle bottom-left line: which effort level the next turn runs at. */
 function effortLine(ctx, cols) {
   const t = themeOf(ctx);
-  const txt = `● ${ctx.effort || 'high'} · /effort`;
+  const txt = `● ${ctx.effort || 'auto'} · /effort`;
   const pad = ' '.repeat(Math.max(0, cols - [...txt].length - 4));
   return [span(t.gray, pad + txt)];
 }
@@ -1111,12 +1111,15 @@ async function runSession(host) {
         return;
       }
       if (type === 'effort') {
-        const levels = ['low', 'medium', 'high'];
-        const chosen = levels[overlay.sel || 0];
+        // The picker's own order, not a second copy of the level names: this
+        // used to re-declare ['low','medium','high'] here while the picker drew
+        // its own table, so the row a user picked and the value it stored were
+        // resolved through different lists.
+        const chosen = overlays.EFFORT_VALUES[overlay.sel || 0];
         overlay = null;
         ctx.effort = chosen;
         host.updateConfig({ effort: chosen });
-        note(`effort: ${chosen}`);
+        note(`effort: ${chosen || 'auto'}`);
         render();
         return;
       }

package/src/commands.js

@@ -46,6 +46,7 @@ const { execSync } = require('node:child_process');
 const { span } = require('./screen.js');
 const { C, BOLD, BOLD_OFF } = require('./theme.js');
 const panels = require('./panels.js');
+const overlays = require('./overlays.js');
 const {
   updateConfig, loadConfig, loadPermissions, savePermissions, addPermissionRule,
   DEFAULT_PERMISSIONS, permissionsPath, configPath,
@@ -93,7 +94,13 @@ const CATEGORIES = [
 
 const categoryLabel = (id) => (CATEGORIES.find((cat) => cat.id === id) || {}).label || id;
 
-const EFFORT_LEVELS = ['low', 'medium', 'high'];
+// One table, shared with the picker that draws it. The two used to be separate
+// lists — this one a string array, chatflow.js's own copy of the same three
+// strings, and overlays.js's label/note rows — so adding a level meant editing
+// three places, and the index a picker row reported was mapped back to a value
+// through whichever list happened to be in scope. EFFORT_VALUES is the picker's
+// own order, `null` first for "auto".
+const EFFORT_LEVELS = overlays.EFFORT_VALUES;
 
 // ── Small handler helpers ─────────────────────────────────────────────────────
 
@@ -348,12 +355,12 @@ const COMMANDS = [
     },
   },
   {
-    name: 'effort', args: ['level'], hint: '[low|medium|high]', category: 'model',
-    desc: 'Set effort level for model usage',
+    name: 'effort', args: ['level'], hint: '[auto|low|medium|high]', category: 'model',
+    desc: 'Set the token budget the pool sizes each turn from',
     handler: async (c, args) => {
       const level = (args.level || '').toLowerCase();
-      if (level && !EFFORT_LEVELS.includes(level)) {
-        note(c, `Unknown effort level "${args.level}". Use ${EFFORT_LEVELS.join(', ')}.`);
+      if (level && level !== 'auto' && !EFFORT_LEVELS.includes(level)) {
+        note(c, `Unknown effort level "${args.level}". Use auto, ${EFFORT_LEVELS.filter(Boolean).join(', ')}.`);
         c.render();
         return true;
       }
@@ -361,9 +368,14 @@ const COMMANDS = [
         c.openOverlay({ type: 'effort', sel: Math.max(0, EFFORT_LEVELS.indexOf(c.ctx.effort)) });
         return true;
       }
-      c.ctx.effort = level;
-      c.saveConfig({ effort: level });
-      note(c, `Effort level: ${level}`);
+      // 'auto' is the absence of a pin, not a fourth rung: it is stored as null
+      // so nothing is sent and the server sizes the turn from the ask.
+      const pinned = level === 'auto' ? null : level;
+      c.ctx.effort = pinned;
+      c.saveConfig({ effort: pinned });
+      note(c, pinned
+        ? `Effort level: ${pinned} — the pool sizes this turn's token budget from it`
+        : 'Effort level: auto — the pool sizes each turn from the ask');
       c.render();
       return true;
     },

package/src/config.js

@@ -59,7 +59,12 @@ const DEFAULT_CONFIG = {
   // aegiscode- name so /model add/remove/switch stay compatible both ways.
   models: null,
   currentModelId: null,
-  effort: 'high',
+  // `null` = no effort pinned, i.e. "auto": each turn is sized by the server
+  // from the ask itself (aegis1 services/pool_brain.py estimate_effort). The
+  // old 'high' was a *pin* on the top rung of the budget ladder — the most the
+  // server can grant — so the CLI's default turn was the most expensive one it
+  // could make, and /effort could only ever move it down.
+  effort: null,
   vim: false,
   lastCwd: '',
 };

package/src/overlays.js

@@ -177,27 +177,38 @@ function renderModelPicker(models, sel = 0, width = 80, height = 24, current = n
 // ── Effort picker overlay (/effort) ──────────────────────────────────────────
 
 const EFFORT_LEVELS = [
-  { label: 'Low', note: 'Fastest, most efficient' },
+  { label: 'Auto', value: null, note: 'Sized per turn from the ask (default)' },
+  { label: 'Low', note: 'Fastest, cheapest budget' },
   { label: 'Medium', note: 'Balanced' },
-  { label: 'High', note: 'Highest quality, slowest' },
+  { label: 'High', note: 'Highest budget, slowest' },
 ];
 
+// The picker's order reduced to the values a selection means, so the row a user
+// picks and the value the session stores can never come from two different
+// lists (commands.js validates against this, chatflow.js resolves the overlay
+// through it). `null` is "auto" — no rung pinned.
+const EFFORT_VALUES = EFFORT_LEVELS.map((lv) => (lv.value === undefined ? lv.label.toLowerCase() : lv.value));
+
 /**
  * @param {number} sel selected index
  * @param {number} width
- * @param {string|null} current the currently-selected effort level
+ * @param {string|null} current the currently-selected effort level (null = auto)
  * @param {Array} [levels] override the level table
  */
 function renderEffortPicker(sel = 0, width = 80, current = null, levels = EFFORT_LEVELS) {
   const lines = [];
   lines.push(blank(width));
   lines.push([span('', ' '), span(C.white + BOLD, 'Select effort'), span(BOLD_OFF, '')]);
-  lines.push([span('', ' '), span(C.gray, 'Controls how much reasoning the model puts into each turn.')]);
+  lines.push([span('', ' '), span(C.gray, 'Sets the token budget the pool sizes each turn from.')]);
   lines.push(blank(width));
   for (let i = 0; i < levels.length; i++) {
     const lv = levels[i];
     const active = i === sel;
-    const cur = current != null && String(current).toLowerCase() === String(lv.label).toLowerCase();
+    // `current == null` is auto, which is the first row's own value — matching
+    // on the label alone would never mark the default as the current choice.
+    const cur = current == null
+      ? lv.value === null
+      : String(current).toLowerCase() === String(lv.label).toLowerCase();
     const left = active ? span(C.lavender, GLYPH.cursor) : span('', ' ');
     const nameSpan = active ? span(C.lavender, lv.label) : span(C.white, lv.label);
     const mark = cur ? span(C.green, ' ' + GLYPH.check) : span('', '');
@@ -283,4 +294,6 @@ module.exports = {
   renderModelPicker,
   renderEffortPicker,
   renderResumeList,
+  EFFORT_LEVELS,
+  EFFORT_VALUES,
 };

package/src/panels.js

@@ -202,7 +202,9 @@ function buildStatus(state, ctx = {}) {
   add('Working directory', s.cwd);
   add('Home', s.home);
   add('Model', s.model);
-  add('Effort', s.effort);
+  // `null` = auto: the pool sizes each turn from the ask, so the row says so
+  // rather than vanishing (add() skips empty values).
+  add('Effort', s.effort || 'auto');
   if (s.thinking != null) add('Thinking', s.thinking ? 'on' : 'off');
   if (s.stream != null) add('Streaming', s.stream === false ? 'off' : 'on');
   if (s.vim != null) add('Vim keymap', s.vim ? 'on' : 'off');

package/vendor/client/aegis.js

@@ -278,6 +278,13 @@ function createClient(opts = {}) {
    *                 so a reasoning-only stream still counts as unanswered.
    *   - `idleTimeoutMs`  override the stalled-stream watchdog for this call
    *                 (a worker fan-out is legitimately silent between passes)
+   *   - `maxTokens`  output ceiling. Omitted from the body when absent so the
+   *                 server's own budget applies — on a pooled request that is
+   *                 the `effort` ladder, and a number sent from here caps it.
+   *   - `effort` / `workers`  pooled-brain budget rung and fan-out size.
+   *                 Forwarded only inside `extra`, as the server reads them off
+   *                 the body (aegis1 services/pool_brain.py parse_brain_request)
+   *                 and sizes the budget from them.
    */
   async function chatCompletion({
     prompt,
@@ -298,9 +305,17 @@ function createClient(opts = {}) {
     // model the server picks its default (no client-invented tier id). `mode`
     // is a legacy server-side shorthand — forwarded verbatim only when the
     // caller supplies it, never defaulted, never built into a model id.
+    //
+    // `max_tokens` is omitted entirely when the caller states none, rather than
+    // defaulted here. The server has its own budget ladder (`mode`/`effort` on
+    // the pooled path) and treats a body max_tokens as a *ceiling* over it, so
+    // an invented 4096 was not a harmless default: it capped every pass of a
+    // pooled-brain fan-out at 4096 and overrode the ladder the caller's effort
+    // selected. Omitting it is the documented way to say "server default" (see
+    // mcp/tools.js's max_tokens description).
     const body = {
       messages: buildMessages(messages, system, prompt),
-      max_tokens: maxTokens || 4096,
+      ...(maxTokens ? { max_tokens: maxTokens } : {}),
       ...(extra || {}),
     };
     if (model) body.model = model;

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

@@ -584,13 +584,18 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
           // model as the fan-out, one sample instead of four — otherwise
           // dropping the fan-out would have quietly changed the model too.
           ...(brainFlag === false ? { mode: 'brain' } : {}),
-          // Only meaningful (and only sent) alongside a running fan-out — aegis1
-          // services/pool_brain.py parse_brain_request reads `effort`/
-          // `workers` straight off the body and clamps them itself
-          // (EFFORT_LEVELS / MAX_WORKERS), so no client-side validation here.
-          // Keyed on the effective brain flag, not on `autonomous`: an opted-out
-          // single pass carries no fan-out tuning it cannot use.
-          ...(brainFlag === true && opts.effort ? { effort: opts.effort } : {}),
+          // `effort` is the budget rung, and it is sent whenever the caller has
+          // one — not only alongside a fan-out. The fan-out is triggered by the
+          // model id (this class sends ``nexus-brain``), so a caller that never
+          // ticked "work autonomously" still ran a pooled call and had no way to
+          // say how big it should be: the server fell through to its own default
+          // rung. That is how a one-word prompt came to reserve the top of the
+          // ladder. A single-pass pass carries it too — inert on that path, but
+          // it keeps the request honest about what it asked for.
+          ...(opts.effort ? { effort: opts.effort } : {}),
+          // Only meaningful with a running fan-out — aegis1 services/pool_brain.py
+          // parse_brain_request reads `workers` straight off the body and clamps
+          // it itself (MAX_WORKERS), so no client-side validation here.
           ...(brainFlag === true && opts.workers ? { workers: opts.workers } : {}),
           // The pool forwards `tools` to the provider and returns tool_calls
           // (aegis1 app.py:7765 → provider, pool_brain synthesis keeps them).