aegis-desktop 0.8.34 → 0.8.35

package/lib/local/engine.js

@@ -797,6 +797,7 @@ function createLocalEngine({
   // remembering "no" makes the first answer stick.
   const sessionDenials = new Map(); // rootSessionId -> Set<toolName>
   const pendingApprovals = new Map(); // approvalId -> { resolve }
+  const pendingRoundAsks = new Map(); // askId -> { resolve }
 
   function sessionAllows(rootId, name) {
     const set = sessionAllowlists.get(rootId);
@@ -911,6 +912,62 @@ function createLocalEngine({
     });
   }
 
+  /** The renderer's rounds-dialog answer resolves the pending
+   *  requestRoundsAsk() promise below. An unknown/already-answered id is a
+   *  no-op, same contract as respondApproval. */
+  function respondRoundsAsk(askId, decision) {
+    const pending = pendingRoundAsks.get(askId);
+    if (!pending) return { ok: false };
+    pendingRoundAsks.delete(askId);
+    pending.resolve(decision === true || decision === 'continue');
+    return { ok: true };
+  }
+
+  /**
+   * Ask the renderer whether to fund another block of tool rounds, mirroring
+   * requestApproval's shape exactly: pushed over `rootOnDelta` as a `{ rounds }`
+   * chunk (the one channel a detached renderer has into a running turn) and
+   * resolved externally via `respondRoundsAsk`. Resolves `true` (fund one more
+   * block) or `false` (stop here) — never throws. Fails safe to `false`: no
+   * listener, an aborted turn, or an unanswered ask must not keep the loop
+   * waiting forever (or, worse, spend rounds nobody agreed to).
+   */
+  function requestRoundsAsk(rootSessionId, rootOnDelta, signal, info) {
+    return new Promise((resolve) => {
+      if (signal && signal.aborted) {
+        resolve(false);
+        return;
+      }
+      const id = randomUUID();
+      let settled = false;
+      const onAbort = () => finish(false);
+      const finish = (decision) => {
+        if (settled) return;
+        settled = true;
+        pendingRoundAsks.delete(id);
+        if (signal) signal.removeEventListener('abort', onAbort);
+        resolve(decision);
+      };
+      if (signal) signal.addEventListener('abort', onAbort, { once: true });
+      pendingRoundAsks.set(id, { resolve: finish });
+      if (typeof rootOnDelta !== 'function') {
+        finish(false);
+        return;
+      }
+      rootOnDelta({
+        delta: '',
+        rounds: {
+          id,
+          sessionId: rootSessionId,
+          spent: info.spent,
+          extensions: info.extensions,
+          max: info.max,
+          size: info.size,
+        },
+      });
+    });
+  }
+
   /**
    * The gate itself: read-only tools and already-session-allowed mutating
    * tools run exactly like executeTool always did. A first-time mutating
@@ -1522,6 +1579,12 @@ function createLocalEngine({
     // synthesis pass) instead of a single provider call. UI-gated to the
     // 'aegis' class only (see AUTONOMOUS_CLASS in app.js).
     const autonomous = cls === 'aegis' && Boolean(payload && payload.autonomous);
+    // Opt-in only: the round-horizon dialog (requestRoundsAsk below) needs a
+    // live renderer on the other end of `rootOnDelta` able to answer it. The
+    // interactive CLI session sets this; the queue worker and `-p` one-shot
+    // runs never do (nobody is there to click), so they keep the old
+    // stop-and-record-session behaviour (sessionRounds below) untouched.
+    const roundsAsk = Boolean(payload && payload.roundsAsk);
     const sessionId = (payload && payload.sessionId) || randomUUID();
     // Recursion depth for the task tool: 0 for a real user turn, N+1 for a
     // subagent spawned by depth N. Never set by an IPC caller — only by
@@ -1797,8 +1860,17 @@ function createLocalEngine({
       }
       // 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 maxRounds = statedRounds || baseRounds + (resumed ? sessionRounds.bonus(baseRounds) : 0);
       let round = 0;
+      // Rounds bought by one confirmed extension, and a hard cap on how many
+      // extensions a single turn may spend — matching the upstream engine's
+      // numbers (src/autonomous.js ROUND_EXTENSION_SIZE/MAX_ROUND_EXTENSIONS)
+      // so a turn behaves the same whether it runs there or here. The cap
+      // exists even though the renderer is the one asking: a dialog that
+      // always says yes must still terminate (8 x baseRounds extra rounds).
+      const ROUND_EXTENSION_SIZE = baseRounds;
+      const MAX_ROUND_EXTENSIONS = 8;
+      let extensions = 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
@@ -1858,11 +1930,49 @@ function createLocalEngine({
         // which is the same "(empty response)" failure the guards below exist
         // to prevent.
         if (round >= maxRounds) {
+          // Before conceding, give an interactive caller the chance to fund
+          // another block of rounds instead of ending the turn outright — the
+          // upstream engine's "asks" contract (src/backend.js requestExtension).
+          // Only reachable with `roundsAsk` AND a live signal: a caller with no
+          // renderer on the other end (queue, `-p`) falls straight through to
+          // the session-hold stop below, unchanged.
+          if (roundsAsk && extensions < MAX_ROUND_EXTENSIONS && !signal.aborted) {
+            const granted = await requestRoundsAsk(rootSessionId, rootOnDelta, signal, {
+              spent: maxRounds,
+              extensions: extensions + 1,
+              max: MAX_ROUND_EXTENSIONS,
+              size: ROUND_EXTENSION_SIZE,
+            });
+            if (granted) {
+              extensions += 1;
+              const spent = maxRounds;
+              maxRounds += ROUND_EXTENSION_SIZE;
+              history.push({
+                role: 'user',
+                content: `You have used all ${spent} tool rounds allowed for this turn; ` +
+                  `${ROUND_EXTENSION_SIZE} more have been granted (do not restart). Continue the task ` +
+                  'from exactly where you stopped — do not re-plan, do not repeat work already done, ' +
+                  'and finish with an answer.',
+              });
+              continue;
+            }
+            // Declined (or the extension cap is spent): fall through to the
+            // same session-hold stop a non-interactive caller gets, so a "no"
+            // here is bit-for-bit the old hard stop rather than a dead end.
+          }
+          // The knob is only advice where nobody could have been asked about
+          // it. An interactive caller was already offered another block of
+          // rounds (requestRoundsAsk above) and declined or spent the cap, so
+          // pointing it at an env var it cannot set from inside the app — and
+          // would have to restart to apply — is obsolete text: drop it. The
+          // queue worker and `-p` one-shots have no dialog, so for them the
+          // variable remains the only lever and is still named.
+          const knob = roundsAsk ? '' : `, or raise ${roundEnvName} for a longer single turn`;
           const note =
             `[stopped at ${maxRounds} tool rounds` +
             `${turnUsage.total_tokens ? `, ${turnUsage.total_tokens.toLocaleString()} tokens` : ''}` +
             `. This session holds the work: your next message here resumes it automatically` +
-            ` (with a continuation preamble), or raise ${roundEnvName} for a longer single turn.]`;
+            ` (with a continuation preamble)${knob}.]`;
           // 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.
@@ -2146,6 +2256,7 @@ function createLocalEngine({
     chat,
     cancel,
     respondApproval,
+    respondRoundsAsk,
     clearSessionApprovals,
     settings,
     unloadLocalModels,

package/main.js

@@ -1430,6 +1430,22 @@ function createModelDispatch(engine) {
     // session" grants so a fresh thread never inherits a prior one's.
     respondApproval: (payload) =>
       engine.respondApproval(payload && payload.approvalId, payload && payload.decision),
+    // Round-horizon gate (desktop/lib/local/engine.js requestRoundsAsk): the
+    // renderer's rounds card answers a pending "fund another block of tool
+    // rounds?" ask here. The ask itself arrives as a `{ rounds }` chunk on the
+    // same chat() delta stream the approval card rides — see
+    // desktop/renderer/app.js renderRoundsCard. An unanswered id is a no-op,
+    // same contract as respondApproval.
+    //
+    // Guarded on the method's existence rather than assuming it: an engine
+    // without the ask can never emit a `{ rounds }` chunk, so this branch is
+    // unreachable there — but a renderer/window pair that is newer than the
+    // engine it drives must get an honest `{ ok: false }` instead of a
+    // TypeError inside the IPC handler.
+    respondRoundsAsk: (payload) =>
+      typeof engine.respondRoundsAsk === 'function'
+        ? engine.respondRoundsAsk(payload && payload.roundsAskId, payload && payload.decision)
+        : { ok: false },
     clearApprovals: (payload) =>
       engine.clearSessionApprovals(payload && payload.sessionId),
   };
@@ -1879,11 +1895,30 @@ function queueEngineWithDeniedApprovals(engine) {
       /* the turn's own error path reports a gate that cannot be answered */
     }
   };
+  // The third net under the same rule, for the round-horizon ask. A queued task
+  // is unattended, so nobody can fund another block and the answer is always
+  // "no" — which is precisely the engine's own non-interactive behaviour (it
+  // stops, files the session hold, and names the env knob). Answering `false`
+  // rather than leaving the promise pending is what keeps a worker from parking
+  // on a card nobody will ever click: an unanswered ask does resolve false
+  // (requestRoundsAsk fails safe), but waiting for the abort instead would look
+  // like a hung task in the queue for however long the turn ran.
+  const stopRounds = (chunk) => {
+    const ask = chunk && chunk.rounds;
+    if (!ask || !ask.id) return;
+    if (typeof engine.respondRoundsAsk !== 'function') return;
+    try {
+      engine.respondRoundsAsk(ask.id, false);
+    } catch {
+      /* as above: the turn reports a gate that cannot be answered */
+    }
+  };
   return {
     ...engine,
     chat(payload, onDelta) {
       return engine.chat(payload, (chunk) => {
         deny(chunk);
+        stopRounds(chunk);
         if (typeof onDelta === 'function') onDelta(chunk);
       });
     },

package/package.json

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

package/preload.js

@@ -357,6 +357,12 @@ const models = {
   // this session" grants; newChat() calls it so a fresh thread starts clean.
   respondApproval: (approvalId, decision) =>
     invokeModel('respondApproval', { approvalId, decision }),
+  // Round-horizon gate: answers a pending `{ rounds }` ask raised by the engine
+  // when a turn has used every tool round it was allowed (see app.js
+  // renderRoundsCard, and requestRoundsAsk in lib/local/engine.js). Same shape
+  // and same channel as respondApproval above.
+  respondRoundsAsk: (roundsAskId, decision) =>
+    invokeModel('respondRoundsAsk', { roundsAskId, decision }),
   clearApprovals: (sessionId) => invokeModel('clearApprovals', { sessionId }),
 };
 

package/renderer/app.js

@@ -2639,7 +2639,27 @@ function hideWelcome() {
 //           window.open (CSP `script-src 'self'` drops nothing here, but the
 //           main process is what validates the URL).
 
-/** Show the connect block only on an unconnected, un-dismissed install. */
+/** Show the connect block while EITHER connect route is still untaken, and
+ *  retire the individual routes that have been taken.
+ *
+ *  This used to hide the whole block — "bring your own key" included — the
+ *  moment `keyConfigured` went true, on the reasoning that a panel still
+ *  advertising a route the user already took is a nag. It is a nag; but the
+ *  two routes are not alternatives, and the user who just redeemed an AEGIS
+ *  key is the one most likely to want a provider key of their own (a model the
+ *  pool does not carry, a turn that is not relayed). Hiding the BYOK path at
+ *  exactly that moment meant the app answered "you have a key" to a question
+ *  nobody had asked, and the two-key pop-up below was left to carry the whole
+ *  explanation. So the gates are now split, one per route, matching the CLI
+ *  welcome screen's `connectRows()`:
+ *
+ *    cloud — retired by an AEGIS account key (that is the thing it pitches);
+ *    byok  — retired by a provider route of the user's own (`providerConfigured`
+ *            — a BYOK key or a local base URL, which never touch aegis.apiKey).
+ *
+ *  Both states are null/false until status is read, so an unknown state keeps
+ *  the block visible: on a cold boot the user has no key far more often than
+ *  not, and renderStatus() calls this again the moment the truth arrives. */
 function applyWelcomeConnect() {
   const box = document.getElementById('welcome-connect');
   if (!box) return;
@@ -2649,15 +2669,22 @@ function applyWelcomeConnect() {
   } catch {
     /* storage disabled — treat as not dismissed */
   }
-  // Both connect routes retire the block: the AEGIS Cloud key (keyConfigured)
-  // and a provider route of the user's own (providerConfigured — a BYOK key or
-  // a local base URL, which never touch aegis.apiKey). A panel that keeps
-  // advertising "Bring your own key" to someone who already did is a nag.
-  //
-  // keyConfigured is null until status is read, so an unknown state keeps the
-  // block visible: on a cold boot the user has no key far more often than not,
-  // and renderStatus() calls this again the moment the truth arrives.
-  box.hidden = dismissed || keyConfigured === true || providerConfigured === true;
+  // `!== true`, not `=== false`: null is "not read yet" and must read as owed.
+  const cloudOwed = keyConfigured !== true;
+  const byokOwed = providerConfigured !== true;
+  box.hidden = dismissed || (!cloudOwed && !byokOwed);
+  // Each route retires on its own, button AND its note — a note left under a
+  // gone button reads as a dangling fragment.
+  setHidden('welcome-cloud', !cloudOwed);
+  setHidden('welcome-cloud-note', !cloudOwed);
+  setHidden('welcome-byok', !byokOwed);
+  setHidden('welcome-byok-note', !byokOwed);
+}
+
+/** Hide/show one cloned panel node by id when it exists. */
+function setHidden(id, hidden) {
+  const el = document.getElementById(id);
+  if (el) el.hidden = hidden;
 }
 
 /**
@@ -2786,7 +2813,8 @@ function dismissWelcomeConnect() {
 // ------------------------------------------- boot: the two-key pop-up
 //
 // The welcome block above pitches the ROUTES ("connect AEGIS Cloud", "bring
-// your own key") and retires the moment either one is taken. This sheet is the
+// your own key") and retires each one as it is taken — keyConfigured for the
+// Cloud row, providerConfigured for the BYOK row. This sheet is the
 // other question, and the one nothing on screen used to answer: this app and
 // the `aegiscode` CLI on the command line are ONE engine over ONE store, so a
 // user who added only one of the two keys gets a surface that refuses turns
@@ -3580,6 +3608,95 @@ function renderApprovalCard(row, approval, beforeSelector) {
   return card;
 }
 
+/**
+ * Render the round-horizon card (`onDelta`'s `{ rounds: { id, spent,
+ * extensions, max, size } }` chunk — see `requestRoundsAsk` in
+ * desktop/lib/local/engine.js).
+ *
+ * This is the desktop half of what the CLI has handled since the ask landed
+ * (`cli/src/app.js` `chunk.rounds` → `confirmRoundsExtension`). Without it the
+ * desktop never opted in (`roundsAsk` was false, because nothing sent it), so a
+ * turn that used its rounds ended with the engine's non-interactive note —
+ * "…or raise AEGIS_CHAT_MAX_ROUNDS for a longer single turn" — naming an
+ * environment variable a packaged Electron app gives its user no way to set.
+ * The engine only says that where nobody could have been asked, so wiring the
+ * ask is what deletes the obsolete line here: with the card on screen the note
+ * drops the knob and keeps the part that is true (the work is held, the next
+ * message resumes it).
+ *
+ * Answers through `models.respondRoundsAsk`; like the approval card it disables
+ * itself on the first click so a double-click cannot send two decisions for one
+ * id. Declining is NOT destructive: the engine falls through to the same
+ * session-hold stop a non-interactive caller gets, so "Stop here" costs the user
+ * nothing they cannot resume.
+ */
+function renderRoundsCard(row, ask, beforeSelector) {
+  if (!row || !ask || !ask.id) return null;
+
+  const spent = Number(ask.spent) || 0;
+  const size = Number(ask.size) || spent;
+  const extensions = Number(ask.extensions) || 1;
+  const max = Number(ask.max) || 8;
+
+  const card = document.createElement('div');
+  card.className = 'approval-card rounds-card';
+  card.dataset.roundsAskId = ask.id;
+
+  const title = document.createElement('div');
+  title.className = 'approval-title';
+  title.textContent = `Round limit reached — keep going?`;
+  card.appendChild(title);
+
+  const summary = document.createElement('div');
+  summary.className = 'approval-summary';
+  // Says the three things the user needs to decide: what the limit is, what
+  // "keep going" buys, and that stopping is a pause rather than a loss. No
+  // environment variable is named, because the card IS the lever now.
+  summary.textContent =
+    `This turn has used all ${spent} tool rounds allowed for it. ` +
+    `${size} more continue the SAME turn — no restart, no repeated work. ` +
+    `Stopping holds everything done so far: your next message resumes it automatically. ` +
+    `(${extensions} of ${max} extensions.)`;
+  card.appendChild(summary);
+
+  const actions = document.createElement('div');
+  actions.className = 'approval-actions';
+
+  const decide = (decision) => {
+    for (const btn of actions.querySelectorAll('button')) btn.disabled = true;
+    card.classList.add('resolved');
+    const tag = document.createElement('div');
+    tag.className = 'approval-decision';
+    tag.textContent = decision ? `Continuing — ${size} more rounds` : 'Stopped — the work is held';
+    card.appendChild(tag);
+    models.respondRoundsAsk(ask.id, decision);
+  };
+
+  const mkButton = (label, cls, decision) => {
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = `approval-btn ${cls}`;
+    btn.textContent = label;
+    btn.addEventListener('click', () => decide(decision));
+    return btn;
+  };
+
+  actions.appendChild(mkButton(`Keep going (${size} more rounds)`, 'allow', true));
+  actions.appendChild(mkButton('Stop here', 'deny', false));
+  card.appendChild(actions);
+
+  let slot = row.querySelector('.approval-slot');
+  if (!slot) {
+    slot = document.createElement('div');
+    slot.className = 'approval-slot';
+    const before = beforeSelector ? row.querySelector(beforeSelector) : null;
+    if (before) row.insertBefore(slot, before);
+    else row.appendChild(slot);
+  }
+  slot.appendChild(card);
+  return card;
+}
+
 function classLabel(cls) {
   const found = classOptions.find((c) => c.class === cls);
   return found ? found.label : cls;
@@ -4555,6 +4672,17 @@ async function send() {
       stickToBottom({ force: true });
       return;
     }
+    if (chunk && chunk.rounds) {
+      const row = ensurePendingRow();
+      row.classList.remove('pending');
+      renderRoundsCard(row, chunk.rounds, '.body');
+      // Same blocked-until-answered reason as the approval card above. The
+      // engine holds the turn open on this promise, and an unanswered ask
+      // resolves `false` — so a card the user never scrolled to would read as
+      // the turn stopping for no reason.
+      stickToBottom({ force: true });
+      return;
+    }
     if (chunk && chunk.tool) {
       // See the flow-stream handler above: the run frame is the CLI's live
       // row. Ignored here, and ignored *before* `toolLog.push` — a run frame
@@ -4579,7 +4707,29 @@ async function send() {
     // All four classes route through the model: surface (the main process
     // decides transport — cloud client, ollama, or a direct provider).
     const data = await models.chat(
-      { class: cls, prompt, model, maxTokens, sessionId, autonomous, effort, workers, messages: historyForModel },
+      {
+        class: cls,
+        prompt,
+        model,
+        maxTokens,
+        sessionId,
+        autonomous,
+        effort,
+        workers,
+        messages: historyForModel,
+        // Opt in to the round-horizon dialog. A live renderer on the other end
+        // of the delta stream is exactly what this flag asserts, and this call
+        // has one (the `{ rounds }` branch of onDelta above answers it via
+        // renderRoundsCard → models.respondRoundsAsk). It is also what retires
+        // the engine's "raise AEGIS_CHAT_MAX_ROUNDS" advice: that line is
+        // written only for callers nobody could ask (see the `knob` note in
+        // lib/local/engine.js), and a packaged app user has no env to set.
+        // The discovery lane (spawnPath) deliberately does NOT pass this: it is
+        // single-shot with no tools, so it can never reach a round horizon, and
+        // opting in would buy a dialog nobody could answer in a fire-and-forget
+        // card.
+        roundsAsk: true,
+      },
       onDelta
     );
 

package/renderer/index.html

@@ -544,14 +544,14 @@
                 <button type="button" class="wc-link" id="welcome-cloud">
                   Connect AEGIS Cloud — I already have a key →
                 </button>
-                <span class="wc-note">
+                <span class="wc-note" id="welcome-cloud-note">
                   Connect it here and the same queue runs on pooled models right
                   away, free, while this window is open.
                 </span>
                 <button type="button" class="wc-link" id="welcome-byok">
                   Bring your own key →
                 </button>
-                <span class="wc-note">
+                <span class="wc-note" id="welcome-byok-note">
                   The free path, and it stays free: exec, write and edit run on
                   your machine, your repos, sessions and keys live on this disk,
                   and a local model server needs no account at all. A provider

package/renderer/style.css

@@ -1525,6 +1525,24 @@ label {
   background: rgba(255, 255, 255, 0.03);
 }
 
+/* The round-horizon card borrows the approval card wholesale — same slot, same
+   buttons, same one-decision-then-disable behaviour — and only re-tints to the
+   accent: it is a budget question about the turn, not a permission question
+   about a tool, and the two can be on screen in the same conversation. Without
+   the tint a user reading quickly would answer the wrong one. */
+.rounds-card {
+  border-color: var(--accent);
+  background: rgba(90, 160, 255, 0.08);
+}
+
+.rounds-card .approval-title {
+  color: var(--accent);
+}
+
+.rounds-card.resolved .approval-title {
+  color: var(--text2);
+}
+
 .approval-title {
   font-family: var(--font-mono);
   font-size: 11px;