aegis-desktop 0.6.0 → 0.6.1

package/lib/local/autonomous.js

@@ -73,13 +73,65 @@ function writtenPath(tool) {
 
 /**
  * The default AEGIS Cloud model for autonomous work: the pooled brain, which
- * is the tier the server fans out to multiple reasoning workers and
- * synthesises. Autonomous tasks are exactly the ones worth that spend, and
- * `nexus-brain` is the canonical id the catalog itself prefers (the other tier
- * spellings are aliases of it — see filterAegisCatalog in engine.js).
+ * is the tier the server can fan out to multiple reasoning workers and
+ * synthesise. `nexus-brain` is the canonical id the catalog itself prefers
+ * (the other tier spellings are aliases of it — see filterAegisCatalog in
+ * engine.js).
+ *
+ * The model id is only the tier. It is NOT what makes an autonomous task
+ * expensive — the fan-out is, and the fan-out is opt-in per task (see
+ * resolveFanout below). This used to be documented the other way round ("the
+ * pooled brain ... autonomous tasks are exactly the ones worth that spend"),
+ * and the worker sent `autonomous: true` on every queued task, so the most
+ * expensive shape of the most expensive tier ran on one-line tasks too.
  */
 const DEFAULT_MODEL = 'nexus-brain';
 
+/**
+ * THE QUEUE RUNS ON AEGIS CLOUD, AND NOTHING ELSE.
+ *
+ * A queued task is billed to the AEGIS pool and every turn it makes goes out
+ * with `class: 'aegis'` (see runTask below) — the pool is the only backend this
+ * worker can reach. So a model id here has to be one the *pool* serves. A
+ * direct-provider id is not a cheaper option the queue could fall back to; it
+ * is a request the pool cannot honour, or worse, a per-provider spelling
+ * (`anthropic`, `groq`, …) that quietly pins one upstream instead of letting
+ * the pool auto-route across whichever providers hold a live key.
+ *
+ * The accept-list is therefore the pooled-brain tier family — the one entry
+ * engine.js's filterAegisCatalog offers for the Aegis Cloud class, plus the
+ * `-smart`/`-neo` tier spellings the server still serves as aliases of it. This
+ * mirrors selectBrainEntry() there rather than re-deriving "anything starting
+ * with nexus-": `nexus-fast` is not a tier the catalog has ever served, and
+ * accepting a made-up id means a queued task that fails at the server after
+ * being picked up, or runs on a tier nobody chose.
+ */
+const AEGIS_MODEL_RE = /^(?:nexus|aegis)-brain(?:-(?:smart|neo))?$/;
+const AEGIS_MODEL_IDS = Object.freeze(['nexus-brain', 'aegis-brain']);
+
+/** True when `id` names an AEGIS Cloud pooled-brain tier (the queue's only models). */
+function isAegisModel(id) {
+  return AEGIS_MODEL_RE.test(String(id == null ? '' : id).trim());
+}
+
+/**
+ * Why a STATED model id cannot be queued, or '' when it can. Blank is not a
+ * refusal — "no pick" is the default model, which resolveModel supplies.
+ *
+ * The message names the pool, because the failure it prevents ("queued on
+ * claude-sonnet-4, ran on — or was billed to — something else") is invisible
+ * otherwise: `class: 'aegis'` would be sent with an id the server does not
+ * serve, and the task would come back as an opaque error minutes later.
+ */
+function modelRefusal(id) {
+  const stated = String(id == null ? '' : id).trim();
+  if (!stated || isAegisModel(stated)) return '';
+  return (
+    `the autonomous queue runs Aegis Cloud models only (${DEFAULT_MODEL}, ` +
+    `${AEGIS_MODEL_IDS.join('/')} aliases); "${stated}" is not one`
+  );
+}
+
 /** Phrase match for "work autonomously" in a prompt or a queued task. */
 const AUTONOMOUS_REQUEST_RE =
   /\bautonomously\b|\bon your own\b|\bwithout asking\b|\bend[- ]to[- ]end\b|\bno (?:more )?questions\b|\bfully autonomous\b|\bqueue it\b/i;
@@ -160,23 +212,92 @@ function withRoundHorizon(rounds, env, fn) {
 }
 
 /**
- * The model an autonomous task runs on: an explicit pick wins, then the
- * environment (so a systemd timer can pin a cheap tier), then the pooled
- * brain. Never the interactive session's model — a queue survives the session
- * that queued it, so it cannot inherit that session's choice.
+ * The model an autonomous task runs on: an explicit pick wins, then an AEGIS
+ * Cloud pin in the environment (so a systemd timer can choose a tier), then the
+ * pooled brain. Never the interactive session's model — a queue survives the
+ * session that queued it, so it cannot inherit that session's choice.
+ *
+ * TWO DIFFERENT TREATMENTS FOR TWO DIFFERENT SOURCES, on purpose:
+ *
+ *   - a pick that came from the TASK is returned verbatim, even when it is
+ *     wrong. Substituting a correct model for a stated one is how a queue
+ *     "runs on nexus-brain" while the file says otherwise; the caller refuses
+ *     it out loud instead (modelRefusal, queue.addTask, and the pre-flight in
+ *     runTask).
+ *   - a non-Aegis value in the ENVIRONMENT is skipped, because AEGIS_MODEL is
+ *     shared with the interactive surfaces (which run direct providers), so a
+ *     stray value there is not a statement about the queue. Refusing every
+ *     task over it would break drains for a reason that is not the task's
+ *     fault; a fallback to the pooled brain keeps the drain honest and on-cloud.
  */
 function resolveModel({ model, env } = {}) {
   const e = env || process.env;
   const picked = String(model || '').trim();
   if (picked) return picked;
   const fromEnv = String(e.AEGIS_AUTONOMOUS_MODEL || e.AEGIS_MODEL || '').trim();
-  return fromEnv || DEFAULT_MODEL;
+  return isAegisModel(fromEnv) ? fromEnv : DEFAULT_MODEL;
 }
 
-/** Effort rung for an unattended turn: high unless the caller/environment says otherwise. */
-function resolveEffort({ effort, env } = {}) {
+/**
+ * The environment pin the queue had to ignore, or '' when there was none.
+ *
+ * Reported (not silent) because an operator who exported
+ * AEGIS_AUTONOMOUS_MODEL=deepseek-v4-flash asked for a model and is not getting
+ * it: the queue falls back to the pool, and the one place that says so is this
+ * string, which runTask emits as a note and the desktop card shows.
+ */
+function ignoredEnvModel({ model, env } = {}) {
+  if (String(model || '').trim()) return ''; // the task's own pick is what counts
+  const e = env || process.env;
+  const fromEnv = String(e.AEGIS_AUTONOMOUS_MODEL || e.AEGIS_MODEL || '').trim();
+  if (!fromEnv || isAegisModel(fromEnv)) return '';
+  const which = String(e.AEGIS_AUTONOMOUS_MODEL || '').trim() ? 'AEGIS_AUTONOMOUS_MODEL' : 'AEGIS_MODEL';
+  return `${which}="${fromEnv}" is not an Aegis Cloud model — running on ${DEFAULT_MODEL} instead`;
+}
+
+/**
+ * Whether a queued task runs the pooled-brain worker fan-out (aegis1
+ * services/pool_brain.py) or one plain turn on the same tier.
+ *
+ * COST IS THE REASON THIS IS OPT-IN. The fan-out is the single biggest
+ * multiplier this app can put on a bill: pool_brain spawns up to `workers`
+ * reasoning workers plus a synthesis pass, re-sends the task context to every
+ * one of them, and sizes each from the same effort ladder. A 3-worker
+ * high-effort task is therefore roughly four full reasoning calls against a
+ * 65536-token ladder, where the identical task single-pass is one call on the
+ * medium rung. The fan-out earns that on genuinely open-ended investigation
+ * ("why did X regress across this repo"); it is pure waste on a task that
+ * already names the file to edit.
+ *
+ * Precedence: the task's own `autonomous: true` (or `singlePass: false`, the
+ * explicit "fan me out") wins, then AEGIS_AUTONOMOUS_FANOUT=1 in the
+ * environment, else single pass.
+ */
+function resolveFanout(item = {}, env = process.env) {
+  const it = item || {};
+  if (it.autonomous === true || it.singlePass === false) return true;
+  const e = env || process.env;
+  return /^(1|true|yes|on)$/i.test(String(e.AEGIS_AUTONOMOUS_FANOUT || '').trim());
+}
+
+/**
+ * Effort rung for an unattended turn.
+ *
+ * The rung is a spend knob, not a quality slider: the pooled class sizes its
+ * whole budget ladder from it (aegis1 services/pool_brain.py pass_budgets:
+ * low/medium/high -> 16384/32768/65536 tokens TOTAL across the fan-out), and
+ * the engine uses it for any model that reasons against its own output budget.
+ * `high` is the right rung for a fan-out — it is what buys a synthesis pass
+ * worth reading — but on a single pass it is a 2x over medium for budget
+ * nobody reads, so the default follows the shape of the task rather than
+ * always being the most expensive rung. An explicit pick (item.effort) or
+ * AEGIS_AUTONOMOUS_EFFORT still wins outright.
+ */
+function resolveEffort({ effort, env, fanout } = {}) {
   const e = env || process.env;
-  return String(effort || e.AEGIS_AUTONOMOUS_EFFORT || 'high');
+  const stated = String(effort || e.AEGIS_AUTONOMOUS_EFFORT || '').trim();
+  if (stated) return stated;
+  return fanout ? 'high' : 'medium';
 }
 
 /**
@@ -290,8 +411,24 @@ function createQueueWorker({ engine, env = process.env, log = () => {}, git = gi
    */
   async function runTask(item, { carry = '', commit } = {}) {
     const cwd = item.cwd || process.cwd();
+    // Aegis Cloud or nothing — checked BEFORE the turn, not at the server. An
+    // item whose model is not a pooled tier (a hand-edited queue file, a
+    // `--model` the CLI accepted before this rule existed, another host's
+    // older build) would otherwise go out as `class: 'aegis'` with an id the
+    // pool does not serve: billed work if it happens to be a per-provider
+    // spelling, an opaque server error otherwise. Failing here names the model
+    // and the allowed ones, and costs nothing.
+    const refusal = modelRefusal(item.model);
+    if (refusal) {
+      const failed = { ok: false, error: refusal, model: item.model, ms: 0 };
+      emit({ type: 'finish', taskId: item.id, ok: false, result: failed });
+      return failed;
+    }
     const model = resolveModel({ model: item.model, env });
-    const effort = resolveEffort({ effort: item.effort, env });
+    const ignored = ignoredEnvModel({ model: item.model, env });
+    if (ignored) emit({ type: 'note', taskId: item.id, note: ignored });
+    const fanout = resolveFanout(item, env);
+    const effort = resolveEffort({ effort: item.effort, env, fanout });
     const rounds = maxRounds(env, item.maxRounds);
     // Approval requests have no one to answer them here; see the header.
     let approvalAsked = null;
@@ -331,7 +468,7 @@ function createQueueWorker({ engine, env = process.env, log = () => {}, git = gi
     const wantCommit = commit === undefined ? Boolean(item.commit) : Boolean(commit);
     const before = wantCommit ? safe(() => git.gitStatusSnapshot(cwd), null) : null;
 
-    emit({ type: 'start', taskId: item.id, model, cwd, rounds });
+    emit({ type: 'start', taskId: item.id, model, cwd, rounds, fanout, effort });
     const started = now();
     let result;
     try {
@@ -341,13 +478,16 @@ function createQueueWorker({ engine, env = process.env, log = () => {}, git = gi
             class: 'aegis',
             model,
             prompt: taskPrompt(item, { carry, rounds }),
-            // The pooled brain ("work autonomously" in the GUI): the server fans
-            // the round out to several reasoning workers and synthesises. A
-            // `singlePass` task opts out — the retry/write-up passes in the
-            // engine send `brain: false` for exactly this reason.
-            autonomous: !item.singlePass,
+            // The pooled-brain fan-out ("fan out this turn" in the GUI chat
+            // header, and opt-in here): the server fans the round out to
+            // several reasoning workers and synthesises. It costs about
+            // workers+1 full reasoning calls, so it travels only when the task
+            // asked for it — see resolveFanout above. A `singlePass` task is
+            // the default for exactly that reason; the retry/write-up passes in
+            // the engine send `brain: false` for the same one-call reason.
+            autonomous: fanout,
             effort,
-            workers: item.workers || undefined,
+            workers: fanout ? item.workers || undefined : undefined,
             // The turn's working directory rides on `env`: engine.js reads the
             // tool loop's cwd from envFor(payload), so a top-level `cwd` field
             // is a directory the engine would ignore and every tool would run
@@ -582,13 +722,18 @@ function commitMessage(item) {
 module.exports = {
   DEFAULT_MODEL,
   DEFAULT_ROUNDS,
+  AEGIS_MODEL_IDS,
+  isAegisModel,
+  modelRefusal,
   WRITE_TOOLS,
   writtenPath,
   isAutonomousRequest,
   maxRounds,
   withRoundHorizon,
   resolveModel,
+  ignoredEnvModel,
   resolveEffort,
+  resolveFanout,
   autonomousDirective,
   taskPrompt,
   appendDigest,

package/lib/local/engine.js

@@ -383,7 +383,14 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
    *  settings store's own accessor; then the safe default — ON, i.e. the gate
    *  stays up, so a store that predates the toggle can never silently
    *  disable it. */
+  // Session-scoped round accounting (lib/local/session-rounds.js): the
+  // tool-round cap is held against the *session* rather than the single turn,
+  // so a turn that reaches its horizon is resumed by the next turn in the same
+  // conversation instead of being cut off with the work lost. Module-level
+  // state, so it survives `send()` and even a fresh engine instance.
+  const sessionRounds = require('./session-rounds.js');
   const confirmModeEnabled = () => {
+
     if (typeof getConfirmMode === 'function') return getConfirmMode() !== false;
     if (settings && typeof settings.getConfirmMode === 'function') {
       const value = settings.getConfirmMode();
@@ -1020,12 +1027,47 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
       // 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;
+      // A stated horizon (env) still wins outright — an explicit number is the
+      // user overriding the engine, not something the ledger may pad.
+      const roundEnvName = autonomous ? 'AEGIS_AUTONOMOUS_MAX_ROUNDS' : 'AEGIS_CHAT_MAX_ROUNDS';
+      const statedRounds = (() => {
+        const raw = Number.parseInt(process.env[roundEnvName] || '', 10);
+        return Number.isFinite(raw) && raw > 0 ? raw : 0;
       })();
+      const baseRounds = statedRounds || (autonomous ? 40 : 24);
+
+      // Did the previous turn in this session die at its horizon? If so, this
+      // turn is a continuation of it: same job, unfinished, and the model has
+      // to be told — a cold restart is what made the old cap lose work.
+      let roundSessionKey = sessionRounds.keyFor(payload, history);
+      let resumed = sessionRounds.take(roundSessionKey);
+      if (!resumed) {
+        // The caller minted a fresh key this turn (no stated session id and a
+        // rebuilt history array). Adopt the held work rather than dropping it,
+        // but only within the ledger's recency window.
+        const adopted = sessionRounds.adopt();
+        if (adopted) {
+          resumed = adopted.entry;
+          roundSessionKey = adopted.key;
+        }
+      }
+      if (resumed) {
+        const preamble = sessionRounds.resumePreamble(resumed);
+        // Round 1's ask travels as `prompt`; a follow-up dispatch (and every
+        // turn that skips the shorthand) has to receive it through history.
+        if (prompt) prompt = `${preamble}\n\n${prompt}`;
+        else history.push({ role: 'user', content: preamble });
+        if (rootOnDelta) {
+          rootOnDelta({
+            delta:
+              `\n\n[resuming work this session left unfinished at ${resumed.rounds} tool rounds` +
+              `${resumed.interruptions > 1 ? ` (cut off ${resumed.interruptions}×)` : ''}…]\n`,
+          });
+        }
+      }
+      // A resumed turn gets a small bonus on top of the base horizon so
+      // re-orientation does not consume the new budget before any work lands.
+      const maxRounds = statedRounds || baseRounds + (resumed ? sessionRounds.bonus(baseRounds) : 0);
       let round = 0;
 
       // Token accounting for the whole TURN, not just its last round. An
@@ -1084,13 +1126,26 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
           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'}.]`;
+            `. This session holds the work: your next message here resumes it automatically` +
+            ` (with a continuation preamble), or raise ${roundEnvName} for a longer single turn.]`;
+          // File the interruption before returning, so the horizon is a pause
+          // in the session rather than the end of the job. `chain` carries the
+          // count forward across resumes.
+          const held = sessionRounds.record(roundSessionKey, {
+            rounds: round,
+            tokens: turnUsage.total_tokens || 0,
+            note,
+            chain: resumed ? resumed.interruptions : 0,
+          });
           if (rootOnDelta) rootOnDelta({ delta: `\n\n${note}` });
           return withTurnUsage({
             model: base.model,
             choices: [{ message: { content: note }, finish_reason: 'length' }],
             stoppedOnRounds: true,
+            heldForSession: true,
+            heldRounds: held.rounds,
+            sessionInterruptions: held.interruptions,
+            resumedFrom: roundSessionKey,
           });
         }
         round += 1;

package/lib/local/queue.js

@@ -179,17 +179,32 @@ function upsert(items, entry) {
  * with it as the tool loop's working directory), `model` is the AEGIS Cloud
  * model id to run it on, and `commit` asks the worker to commit what the task
  * changed (scoped — see autonomous.js).
+ *
+ * AEGIS CLOUD ONLY, REFUSED AT THE DOOR. The worker sends every task out as
+ * `class: 'aegis'`, so a model the pool does not serve cannot run here at all —
+ * it is a task that fails minutes into a drain, after being picked up, with an
+ * opaque server error. `model: null` stays legal: that is "no pick", and
+ * autonomous.resolveModel fills in the pooled brain. Anything else has to pass
+ * that module's own accept-list, so the CLI (`aegiscode autonomous add
+ * --model`), the desktop card and a hand-written queue file are all held to the
+ * same rule. Required lazily: queue.js is a dependency of autonomous.js, and
+ * this check must not turn that into a load-order cycle.
  */
 function addTask(env, opts = {}) {
   const task = String(opts.task == null ? '' : opts.task).trim();
   if (!task) throw new Error('queue: a task needs text');
+  const statedModel = String(opts.model == null ? '' : opts.model).trim();
+  if (statedModel) {
+    const refusal = require('./autonomous.js').modelRefusal(statedModel);
+    if (refusal) throw new Error(`queue: ${refusal}`);
+  }
   const items = loadQueue(env);
   const now = opts.now || Date.now();
   const entry = {
     id: nextId(items),
     task,
     cwd: opts.cwd || process.cwd(),
-    model: opts.model || null,
+    model: statedModel || null,
     effort: opts.effort || null,
     workers: Number.isInteger(opts.workers) ? opts.workers : null,
     singlePass: Boolean(opts.singlePass),

package/lib/local/session-rounds.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/**
+ * Session-scoped tool-round ledger.
+ *
+ * The engine's tool-round cap used to be a wall. A turn that reached it ended
+ * mid-investigation with `[stopped at 24 tool rounds…]`, and because the
+ * accounting lived only for the duration of that call, the next turn in the
+ * same conversation started from zero: it knew nothing about the horizon that
+ * had just cut it off, so a long job could be truncated by the cap forever
+ * without ever being finished.
+ *
+ * This makes the cap *session* state instead of turn state:
+ *
+ *   - a turn that reaches its horizon records the unfinished work against the
+ *     session key (rounds spent, tokens, the note the user saw);
+ *   - the next turn in that session takes the record — consuming it, so one
+ *     resume per interruption and a chain of interruptions is a chain of
+ *     deliberate asks, never an automatic loop — and gets a continuation
+ *     preamble plus a small round bonus, so re-orientation does not eat the
+ *     new horizon before any work happens;
+ *   - an entry nobody comes back for expires after TTL_MS.
+ *
+ * State is module-level, so it outlives a turn, a `send()` and whichever
+ * engine instance the desktop happens to be using. It never leaves the
+ * process and is never written to disk.
+ */
+
+/** How long an unclaimed interruption stays resumable (30 min). */
+const TTL_MS = 30 * 60 * 1000;
+/** Bound on live entries: a long-lived app must not grow without limit. */
+const MAX_ENTRIES = 64;
+
+const entries = new Map(); // key -> { rounds, tokens, note, at, interruptions }
+const historyKeys = new WeakMap(); // history[] -> key
+let historyKeySeq = 0;
+
+/** Drop expired entries, then the oldest ones past the bound. */
+function prune(now = Date.now()) {
+  for (const [key, entry] of entries) {
+    if (now - entry.at > TTL_MS) entries.delete(key);
+  }
+  while (entries.size > MAX_ENTRIES) {
+    // Map iteration is insertion-ordered and `record` re-inserts on write, so
+    // the first key is the oldest.
+    const oldest = entries.keys().next();
+    if (oldest.done) break;
+    entries.delete(oldest.value);
+  }
+  return entries.size;
+}
+
+/**
+ * The key an interruption is filed under. A caller that states its session
+ * (desktop payloads carry an id) gets an exact match; otherwise the working
+ * directory, then the identity of the history array, then a single shared
+ * bucket. `adopt` covers the remaining case — a caller that mints a fresh key
+ * every turn.
+ */
+function keyFor(payload, history) {
+  const p = payload && typeof payload === 'object' ? payload : {};
+  const stated = p.sessionKey || p.sessionId || p.chatId || p.threadId || p.conversationId;
+  if (typeof stated === 'string' && stated.trim()) return `s:${stated.trim()}`;
+  if (typeof p.cwd === 'string' && p.cwd.trim()) return `cwd:${p.cwd.trim()}`;
+  if (history && typeof history === 'object') {
+    let key = historyKeys.get(history);
+    if (!key) {
+      historyKeySeq += 1;
+      key = `hist-${historyKeySeq}`;
+      historyKeys.set(history, key);
+    }
+    return key;
+  }
+  return 'default';
+}
+
+/**
+ * Extra rounds granted to a resuming turn. Deliberately small and bounded: the
+ * point of resuming is to *continue* work that already exists, not to hand out
+ * a second full horizon (every round re-sends the whole conversation, so this
+ * is the cheapest way to make the cap non-fatal).
+ */
+function bonus(base) {
+  const n = Number.isFinite(base) && base > 0 ? base : 0;
+  return Math.max(4, Math.ceil(n / 4));
+}
+
+/** Peek without consuming — the entry stays resumable. */
+function peek(key, now = Date.now()) {
+  prune(now);
+  return entries.get(key) || null;
+}
+
+/** Claim the interruption for `key`, if any. Consuming: a second call gets null. */
+function take(key, now = Date.now()) {
+  prune(now);
+  const entry = entries.get(key);
+  if (!entry) return null;
+  entries.delete(key);
+  return entry;
+}
+
+/**
+ * Claim the most recent interruption filed under ANY key. This is the bridge
+ * for a caller whose key does not survive between turns: the next turn on this
+ * process adopts the held work rather than losing it. Bounded by `maxAgeMs` so
+ * an unrelated new conversation is not handed yesterday's job.
+ */
+function adopt({ now = Date.now(), maxAgeMs = 10 * 60 * 1000 } = {}) {
+  prune(now);
+  let bestKey = null;
+  let best = null;
+  for (const [key, entry] of entries) {
+    if (now - entry.at > maxAgeMs) continue;
+    if (!best || entry.at > best.at) {
+      best = entry;
+      bestKey = key;
+    }
+  }
+  if (!best) return null;
+  entries.delete(bestKey);
+  return { key: bestKey, entry: best };
+}
+
+/**
+ * File an interruption. `chain` carries the count forward from the entry this
+ * turn resumed, so `interruptions` reports how many times one job has been cut
+ * off — visible in the note and useful when deciding to raise the horizon.
+ */
+function record(key, { rounds, tokens, note, chain } = {}, now = Date.now()) {
+  prune(now);
+  const prior = entries.get(key);
+  const entry = {
+    rounds: Number.isFinite(rounds) ? rounds : 0,
+    tokens: Number.isFinite(tokens) ? tokens : 0,
+    note: typeof note === 'string' ? note : '',
+    at: now,
+    interruptions: (Number.isFinite(chain) ? chain : prior && prior.interruptions) || 0,
+  };
+  entry.interruptions += 1;
+  entries.delete(key);
+  entries.set(key, entry); // re-insert so Map order stays age order
+  prune(now);
+  return entry;
+}
+
+/** The instruction that turns a cold start into a continuation. */
+function resumePreamble(entry) {
+  const rounds = entry && entry.rounds ? entry.rounds : 'the previous turn\'s';
+  const tokens = entry && entry.tokens ? ` (${entry.tokens.toLocaleString()} tokens)` : '';
+  return (
+    `[session resume] The previous turn in this conversation was cut off at ${rounds} tool rounds${tokens} ` +
+    'because it reached the round horizon, so the work it started is unfinished. Continue that work now: ' +
+    'do not restart, do not re-do steps that already completed, and do not treat the interruption as a ' +
+    'failure to report. Pick up the next unfinished step and finish with a written answer.'
+  );
+}
+
+/** Read-only snapshot for the UI (and for tests). */
+function state(now = Date.now()) {
+  prune(now);
+  return {
+    size: entries.size,
+    ttlMs: TTL_MS,
+    maxEntries: MAX_ENTRIES,
+    entries: [...entries].map(([key, entry]) => ({ key, ...entry })),
+  };
+}
+
+/** Test hook: forget everything. */
+function reset() {
+  entries.clear();
+  return entries.size;
+}
+
+module.exports = {
+  TTL_MS,
+  MAX_ENTRIES,
+  keyFor,
+  bonus,
+  peek,
+  take,
+  adopt,
+  record,
+  resumePreamble,
+  state,
+  reset,
+};

package/main.js

@@ -1357,6 +1357,11 @@ function createQueueDispatch({
       draining,
       stopping: stopRequested,
       defaultCwd: process.cwd(),
+      // What a task with no model of its own actually runs on. The queue is
+      // Aegis Cloud only, so this is a pooled tier id — and the card prints it,
+      // because "which model is this drain spending on" was previously
+      // unanswerable from the UI.
+      defaultModel: autonomous.resolveModel({ env }),
       queueFile: queue.queuePath(env),
       runs: queue.readRuns(env, { limit: 20 }),
     };
@@ -1385,6 +1390,13 @@ function createQueueDispatch({
     if (!isExistingDir(cwd)) return { error: `not a directory: ${cwd}` };
 
     const model = String(p.model == null ? '' : p.model).trim().slice(0, 120) || null;
+    // Aegis Cloud only (autonomous.js modelRefusal): the worker's requests go
+    // out as `class: 'aegis'`, so a model the pool does not serve is a task that
+    // fails inside a drain. Refused HERE so the card gets the reason at the
+    // moment of queueing instead of a red row later. queue.addTask enforces the
+    // same rule for the CLI and for hand-written queue files.
+    const modelRefusal = model ? autonomous.modelRefusal(model) : '';
+    if (modelRefusal) return { error: modelRefusal };
     const effortRaw = String(p.effort == null ? '' : p.effort).trim().toLowerCase();
     return {
       opts: {
@@ -1394,6 +1406,12 @@ function createQueueDispatch({
         effort: QUEUE_EFFORTS.has(effortRaw) ? effortRaw : null,
         workers: clampInt(p.workers, 1, QUEUE_MAX_WORKERS),
         maxRounds: clampInt(p.maxRounds, 1, QUEUE_MAX_ROUNDS),
+        // The pooled-brain fan-out is opt-in (autonomous.js resolveFanout):
+        // it costs about workers+1 full reasoning calls on one task, so the
+        // card has to ask for it per task. queue.addTask stores the inverse
+        // (`singlePass`), which is also the field a hand-written queue file
+        // or the CLI uses.
+        singlePass: !(p.fanout === true || p.autonomous === true),
         commit: Boolean(p.commit),
         source: 'desktop',
       },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "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",
@@ -29,7 +29,7 @@
     "icon": "node scripts/generate-icon.mjs",
     "dist": "npm run predist && electron-builder",
     "dist:dir": "npm run predist && electron-builder --dir",
-    "check": "node --check main.js && node --check preload.js && node --check renderer/app.js && node --check renderer/quick.js && node --check renderer/budget.js && node --check renderer/usage.js && node --check renderer/stream-policy.js && node --check renderer/transcript-view.js && node --check renderer/markdown.js && node --check renderer/vendor/aegis-highlight.js && node --check scripts/predist.mjs && node --check scripts/generate-icon.mjs && node --check lib/local/context.js && node --check lib/local/providers.js && node --check lib/local/ollama.js && node --check lib/local/engine.js && node --check lib/local/tools.js && node --check lib/local/prompt.js && node --check lib/local/shell.js && node --check lib/local/agents.js && node --check lib/local/queue.js && node --check lib/local/autonomous.js && node --check lib/settings.js && node --check lib/sync/sessions.js && node --check lib/sync/memory-queue.js && node --check lib/window-state.js && node --check lib/deep-link.js && node --check lib/quick-launcher.js && node --check bin/aegis.js",
+    "check": "node --check main.js && node --check preload.js && node --check renderer/app.js && node --check renderer/quick.js && node --check renderer/budget.js && node --check renderer/usage.js && node --check renderer/stream-policy.js && node --check renderer/transcript-view.js && node --check renderer/markdown.js && node --check renderer/vendor/aegis-highlight.js && node --check scripts/predist.mjs && node --check scripts/generate-icon.mjs && node --check lib/local/context.js && node --check lib/local/providers.js && node --check lib/local/ollama.js && node --check lib/local/engine.js && node --check lib/local/session-rounds.js && node --check lib/local/tools.js && node --check lib/local/prompt.js && node --check lib/local/shell.js && node --check lib/local/agents.js && node --check lib/local/queue.js && node --check lib/local/autonomous.js && node --check lib/settings.js && node --check lib/sync/sessions.js && node --check lib/sync/memory-queue.js && node --check lib/window-state.js && node --check lib/deep-link.js && node --check lib/quick-launcher.js && node --check bin/aegis.js",
     "test:shell": "node ../test/desktop-shell.mjs",
     "test:model": "node ../test/model-dispatch.mjs",
     "test:budget": "node ../test/budget.test.mjs",

package/renderer/app.js

@@ -891,6 +891,12 @@ function queueStatusMark(status) {
 /** The outcome line under a task: what happened, or why it did not. */
 function queueMetaText(item) {
   const bits = [item.status];
+  // Which model and which shape, per row. Both are spend facts the card used
+  // to hide: an unpinned task runs main.js's defaultModel (a pooled tier), and
+  // a task is a single pass unless it was queued with `fanout` — the difference
+  // is roughly (workers + 1) full reasoning calls.
+  if (item.model) bits.push(item.model);
+  bits.push(item.singlePass === false || item.autonomous === true ? 'fan-out' : 'single pass');
   if (item.status === 'error') {
     bits.push(item.error ? String(item.error) : 'failed — no reason recorded');
   } else if (item.status === 'done') {
@@ -977,6 +983,10 @@ function renderQueueState(state) {
   if (state.running) bits.push(`running #${state.running.id}`);
   else if (queueDraining) bits.push('draining…');
   bits.push(`${state.pending || 0} pending`);
+  // What the queue can spend on at all: Aegis Cloud, and which tier an
+  // unpinned task lands on (main.js snapshot().defaultModel resolves it the
+  // same way the worker does, so the card cannot disagree with the bill).
+  if (state.defaultModel) bits.push(`Aegis Cloud · ${state.defaultModel}`);
   if (queueDraining && state.stopping) bits.push('stopping after this task');
   if (els.queueHint) {
     els.queueHint.textContent = [queueNote, bits.join(' · ')].filter(Boolean).join(' · ');

package/renderer/index.html

@@ -142,14 +142,21 @@
           for="autonomous-toggle"
           id="autonomous-toggle-wrap"
           hidden
-          title="Let the model work autonomously: fan out to multiple reasoning workers and synthesize their findings into one answer. Aegis Cloud models only."
+          title="Fan THIS chat turn out to several Aegis Cloud reasoning workers and synthesize their findings into one answer. Aegis Cloud only, and off by default because it costs about (workers + 1) full model calls per turn. This is a per-turn setting for the thread; it does not govern the unattended queue below, which runs each queued task on a single pass unless that task asks for the fan-out."
         >
           <input type="checkbox" id="autonomous-toggle" />
-          <span>work autonomously</span>
+          <span>fan out this turn</span>
         </label>
         <div id="autonomous-controls" class="autonomous-controls" hidden>
           <label for="autonomous-workers">Workers</label>
-          <input type="number" id="autonomous-workers" min="1" max="8" step="1" />
+          <input
+            type="number"
+            id="autonomous-workers"
+            min="1"
+            max="8"
+            step="1"
+            title="How many reasoning workers this turn fans out to. Every worker is a separate full model call on the same tier, so the turn costs roughly this number plus one times a normal one — higher is not automatically better."
+          />
         </div>
         <p class="hint" id="model-hint"></p>
       </section>