aegis-desktop 0.6.1 → 0.7.1

package/README.md

@@ -45,6 +45,88 @@ queue that flushes on each "Sync now" or heartbeat retry. The **remember**
 button on any assistant reply pins that message to cross-machine memory —
 queued locally if you're offline.
 
+## Autonomous queue
+
+The unattended work queue, shared with the CLI: tasks are appended to
+`~/.aegiscode/queue.jsonl` and drained later, one at a time, with tool approval
+**disabled** — there is nobody there to click an approval card. The desktop
+sidebar's queue card and `aegiscode autonomous` are two views of the same file.
+
+```bash
+aegiscode autonomous add "fix the flaky retry test" --cwd ~/repo --commit
+aegiscode autonomous list
+aegiscode autonomous run                 # drain one task, then stop
+aegiscode autonomous proceed --max 3     # drain up to three
+aegiscode autonomous reconcile --auto    # queue the next unfinished PLAN.md phase, then drain it
+aegiscode autonomous retry <id>          # put a finished task back
+aegiscode autonomous clear --all         # empty the queue
+```
+
+A task's text is stored verbatim — `add "fix --json in the parser"` is a task,
+not a flag. Drains commit only the paths that task's own tool layer wrote, so a
+drain never sweeps a peer's in-flight edits into your commit.
+
+### Aegis Cloud only
+
+A queued task runs on the pooled brain — **`nexus-brain`** (alias
+`aegis-brain`) — for the same reason the Claude Code plugin is cloud-only: the
+queue hands work to a loop with no human in it, and the pooled class is the one
+the server can route, budget, and bill on its own. A task that *states* another
+model id is refused where you can still see it, instead of failing minutes into
+a drain as an opaque server error:
+
+| Where the model was stated | What happens |
+|---|---|
+| `autonomous add --model <id>` | refused, with the reason, at add time — nothing is queued |
+| A hand-edited `queue.jsonl` | refused pre-flight by the worker (`ms: 0`), before any turn is billed |
+| `AEGIS_MODEL=<id>` in the environment | **ignored for queue runs**, and reported as a note — that variable is shared with the interactive surfaces, which *do* run direct providers |
+| nothing stated | `nexus-brain` |
+
+### What a queued task costs
+
+The queue has two shapes, and the cheap one is the default:
+
+| | Single pass (default) | Fan-out (opt in) |
+|---|---|---|
+| Provider calls | 1 | `workers` + 1 (investigation passes, then synthesis) |
+| Effort rung | `medium` | `high` |
+| How to ask for it | nothing — it is the default | `AEGIS_AUTONOMOUS_FANOUT=1` |
+
+An earlier version sent **every** queued task as a fan-out at the priciest rung:
+one queued line could become several reasoning calls plus a synthesis, all at
+`high`. Making the fan-out opt-in, and letting effort follow the shape of the
+task rather than always topping out, removes the worker multiplication and
+roughly halves the budget on a one-line task. `--effort` (or
+`AEGIS_AUTONOMOUS_EFFORT`) still wins outright, and `--workers N` is only sent
+when you are actually fanning out.
+
+> **Known gap:** there is no `--fanout` flag yet — the opt-in is the environment
+> variable or `singlePass: false` in the task record. `--single-pass` still
+> parses, but it now agrees with the default instead of overriding it.
+
+### A turn that runs out of rounds keeps its work
+
+The tool loop runs against a round horizon: 24 rounds for an interactive turn
+(`AEGIS_CHAT_MAX_ROUNDS`), 40 for a queued one
+(`AEGIS_AUTONOMOUS_MAX_ROUNDS`). A model that reached it mid-turn used to lose
+everything it had assembled, because the cap was *turn* state.
+
+The horizon is now **session state**, held in `lib/local/session-rounds.js`. When
+a turn stops at the cap the interruption is filed against the session, and the
+next message in that conversation is prefixed with a continuation preamble —
+*cut off after N tool rounds; continue, do not restart* — along with
+`max(4, ⌈horizon/4⌉)` extra rounds so re-orientation does not eat the new
+horizon. The resume is announced in the transcript, so it is visible rather
+than silent.
+
+- In-memory and **process-local** (30-minute TTL, 64 entries) — it never leaves
+  the process and never touches disk.
+- Claiming an entry **consumes** it: one resume per interruption, so a chain of
+  interruptions is a chain of deliberate asks, never an automatic loop.
+- A **stated** horizon always wins; the ledger only pads its own default.
+- A caller that mints a fresh session key every turn adopts the most recent held
+  entry (bounded to 10 minutes) instead of losing the work.
+
 ## Keyboard shortcuts
 
 ### In the main window
@@ -124,6 +206,9 @@ main.js              Electron main process — window + IPC shell only
 preload.js           Context-isolated IPC bridge exposed to the renderer
 renderer/            UI (vanilla JS, no framework)
 lib/local/           Model classes, providers, agentic tool loop, prompt
+lib/local/queue.js   The shared work queue (~/.aegiscode/queue.jsonl)
+lib/local/autonomous.js  The unattended worker — directive, digest, commits
+lib/local/session-rounds.js  Session-scoped tool-round ledger (in-memory)
 lib/sync/            Local session/memory persistence + sync queue
 vendor/aegis.js      The AEGIS transport client (thin — no engine logic)
 bin/aegis.js         `aegis` CLI entry point for the global npm install

package/lib/local/autonomous.js

@@ -55,6 +55,15 @@ const gitScope = require('./git-scope.js');
 /** Default tool-round horizon for an unattended turn (matches the engine's). */
 const DEFAULT_ROUNDS = 40;
 
+/**
+ * Consecutive tool-round-horizon stops a queued task gets before runOne gives
+ * up on it as unable to converge and settles it 'error' instead of 'pending'.
+ * Without this bound a task that never finishes would keep proceed()'s drain
+ * loop picking it back up forever — proceed() defaults to no --max at all, so
+ * nothing else would ever stop it.
+ */
+const MAX_ROUND_STOPS = 3;
+
 /**
  * The engine tools that report the file they write, and the argument holding
  * it. This set is the attribution record for a task's commit: `exec` is absent
@@ -326,7 +335,8 @@ function autonomousDirective(rounds = DEFAULT_ROUNDS) {
  */
 function digestLine(item, result) {
   const task = String(item.task || '').replace(/\s+/g, ' ').trim().slice(0, 120);
-  const mark = result && result.ok ? '✓' : '✗';
+  const paused = Boolean(result && result.ok && result.stoppedOnRounds);
+  const mark = paused ? '⏸' : result && result.ok ? '✓' : '✗';
   const files = (result && Array.isArray(result.files) && result.files.slice(0, 6)) || [];
   const where = files.length ? ` — touched: ${files.join(', ')}${result.files.length > files.length ? ', …' : ''}` : '';
   const why = !result || result.ok ? '' : ` — ${String((result && result.error) || 'failed').slice(0, 120)}`;
@@ -616,13 +626,41 @@ function createQueueWorker({ engine, env = process.env, log = () => {}, git = gi
     const items = queue.loadQueue(env);
     const claimed = queue.markRunning(items, item.id, { now: now() });
     if (!claimed) return { ok: false, error: `unknown task #${item.id}`, carry };
+    const priorRoundStops = Number(claimed.roundStops) || 0;
     queue.saveQueue(env, items);
 
-    const result = await runTask(claimed, { carry, commit });
+    const raw = await runTask(claimed, { carry, commit });
+
+    // A task that hit its tool-round horizon has NOT finished — engine.js's
+    // session ledger (session-rounds.js) is holding the rest of the work
+    // under this task's stable session id (sessionIdFor(item.id)), ready to
+    // inject a continuation preamble the moment this item is dispatched
+    // again. Settling it 'done' here (the old behavior) threw that away: the
+    // queue believed the task was finished, so nothing ever sent the next
+    // turn that would have consumed the resume, and a human had to notice
+    // the output was incomplete and re-queue the whole task from scratch.
+    //
+    // Left 'pending' instead, so proceed()'s own drain loop picks it straight
+    // back up — unless it has now failed to converge MAX_ROUND_STOPS times in
+    // a row, at which point looping on it forever (an unattended proceed()
+    // with no --max has no other cap at all) is worse than a visible error.
+    const hitRoundCap = Boolean(raw.ok && raw.stoppedOnRounds);
+    const roundStops = hitRoundCap ? priorRoundStops + 1 : 0;
+    const exhausted = hitRoundCap && roundStops > MAX_ROUND_STOPS;
+    const result = exhausted
+      ? {
+          ...raw,
+          ok: false,
+          error:
+            `stopped at its tool-round horizon ${roundStops} times in a row without finishing — ` +
+            'raise AEGIS_AUTONOMOUS_MAX_ROUNDS or split the task into smaller ones',
+        }
+      : raw;
+    const status = exhausted ? 'error' : hitRoundCap ? 'pending' : result.ok ? 'done' : 'error';
 
     const after = queue.loadQueue(env);
     queue.settle(after, claimed.id, {
-      status: result.ok ? 'done' : 'error',
+      status,
       result: {
         ok: result.ok,
         output: result.output || '',
@@ -634,13 +672,15 @@ function createQueueWorker({ engine, env = process.env, log = () => {}, git = gi
       error: result.ok ? null : result.error,
       now: now(),
     });
+    const settled = queue.findTask(after, claimed.id);
+    if (settled) settled.roundStops = roundStops;
     queue.saveQueue(env, after);
     queue.appendRun(env, {
       id: claimed.id,
       task: claimed.task,
       cwd: claimed.cwd,
       model: resolveModel({ model: claimed.model, env }),
-      status: result.ok ? 'done' : 'error',
+      status: status === 'pending' ? 'stopped' : status,
       at: new Date(now()).toISOString(),
       ms: result.ms,
       usage: result.usage || null,
@@ -722,6 +762,7 @@ function commitMessage(item) {
 module.exports = {
   DEFAULT_MODEL,
   DEFAULT_ROUNDS,
+  MAX_ROUND_STOPS,
   AEGIS_MODEL_IDS,
   isAegisModel,
   modelRefusal,

package/lib/local/engine.js

@@ -945,6 +945,11 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
 
     const system = (payload && payload.system) || buildSystemPrompt(envFor(payload));
     const history = Array.isArray(payload && payload.messages) ? payload.messages.filter(Boolean).slice() : [];
+    // Index into `history` of everything THIS turn added as opposed to what the
+    // caller brought with it. Reset after the resume rehydration below, so a
+    // restored transcript is never re-recorded as if this turn had produced it
+    // (which would double it on every interruption in a chain).
+    let historyStart = history.length;
     let prompt = (payload && payload.prompt) || '';
 
     // Lazily start ONE shell session for this turn; the exec tool shares it so
@@ -1053,6 +1058,26 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
       }
       if (resumed) {
         const preamble = sessionRounds.resumePreamble(resumed);
+        // Restore the interrupted turn's transcript, because the preamble alone
+        // says HOW MUCH was done, not WHAT. The two callers need different
+        // halves of it, so `session-rounds` files both (see `record`):
+        //
+        //   · a caller who brings no conversation of its own — the queue
+        //     worker's fresh dispatch; autonomous.js never sends `messages` —
+        //     has nothing, so it gets the FULL transcript;
+        //   · an interactive chat already carries the prior turns (and the
+        //     "stopped at N rounds" note), so it gets only what THIS turn added
+        //     that the caller never saw: the tool calls and their results. Full
+        //     restore here would duplicate the caller's own text.
+        //
+        // The old `history.length === 0` guard did the first and not the second,
+        // so the resume it was written for a queue task never reached the
+        // interactive sessions this feature is actually used from.
+        if (history.length === 0) {
+          if (Array.isArray(resumed.messages) && resumed.messages.length) history.push(...resumed.messages);
+        } else if (Array.isArray(resumed.added) && resumed.added.length) {
+          history.push(...resumed.added);
+        }
         // 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}`;
@@ -1117,6 +1142,11 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
         prompt = '';
       };
 
+      // From here on, everything pushed into `history` is this turn's own work:
+      // the restored transcript above (if any) belongs to the turn it came from,
+      // and re-recording it would double the ledger on every interruption.
+      historyStart = history.length;
+
       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,
@@ -1136,6 +1166,14 @@ function createLocalEngine({ aegis, settings, ollama, providers, tools, promptBu
             tokens: turnUsage.total_tokens || 0,
             note,
             chain: resumed ? resumed.interruptions : 0,
+            // The actual tool-call/tool-result transcript built up this turn —
+            // everything folded/pushed into `history` by completed rounds — so
+            // a resume can restore real memory of the work, not just a count
+            // of it (see the `resumed.messages` rehydration above).
+            messages: history,
+            // …and only what this turn itself added, for the caller that
+            // already has the rest of `history` in its own conversation.
+            added: history.slice(historyStart),
           });
           if (rootOnDelta) rootOnDelta({ delta: `\n\n${note}` });
           return withTurnUsage({

package/lib/local/queue.js

@@ -266,6 +266,10 @@ function retryTask(env, id, opts = {}) {
   item.updated = opts.now || Date.now();
   delete item.error;
   delete item.pid;
+  // A manual retry is a fresh deliberate ask, so it gets its own full run of
+  // MAX_ROUND_STOPS chances (autonomous.js) rather than inheriting whatever
+  // count a previous, unrelated failure left behind.
+  delete item.roundStops;
   saveQueue(env, items);
   return item;
 }

package/lib/local/session-rounds.js

@@ -13,7 +13,8 @@
  * 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);
+ *     session key (rounds spent, tokens, the note the user saw, and the
+ *     tool-call transcript itself — see `record`'s `messages`);
  *   - 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
@@ -126,8 +127,17 @@ function adopt({ now = Date.now(), maxAgeMs = 10 * 60 * 1000 } = {}) {
  * 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.
+ *
+ * `messages` is the interrupted turn's own tool-call transcript (its live
+ * `history` array at the moment it hit the horizon) — real memory of what was
+ * already done, not just a rounds/tokens count of it. Without it a caller
+ * that supplies no conversation of its own (a queue task's fresh dispatch)
+ * resumes with an empty history: the model is told "continue, don't restart"
+ * with nothing to continue FROM, which is a cold start wearing a note.
+ * Stored as a defensive copy — the caller's `history` array keeps being
+ * mutated by the turn that is returning it.
  */
-function record(key, { rounds, tokens, note, chain } = {}, now = Date.now()) {
+function record(key, { rounds, tokens, note, chain, messages, added } = {}, now = Date.now()) {
   prune(now);
   const prior = entries.get(key);
   const entry = {
@@ -136,6 +146,13 @@ function record(key, { rounds, tokens, note, chain } = {}, now = Date.now()) {
     note: typeof note === 'string' ? note : '',
     at: now,
     interruptions: (Number.isFinite(chain) ? chain : prior && prior.interruptions) || 0,
+    messages: Array.isArray(messages) ? messages.slice() : [],
+    // And what the interrupted turn added on TOP of what its caller already
+    // had. A resuming caller who brings its own conversation (an interactive
+    // chat) must get this half, not `messages` — pushing the full transcript
+    // into a history that already holds its first half duplicates the user's
+    // own turns back to the model.
+    added: Array.isArray(added) ? added.slice() : [],
   };
   entry.interruptions += 1;
   entries.delete(key);

package/lib/settings.js

@@ -54,12 +54,21 @@ const DEFAULT_QUICK_LAUNCHER_SHORTCUT = 'CmdOrCtrl+Shift+Space';
  *  top-level namespace — never inside a provider's `cfg[provider]` object. */
 const CONFIRM_MODE_NAMESPACE = '__confirmMode';
 
+/** Reserved namespace for the persisting-memory preference: `{ enabled }` —
+ *  app-level, not a provider. This is the desktop's counterpart to the CLI's
+ *  `memoryPersist` config key, and the gate `lib/sync/persist-gate.js` reads
+ *  before any automatic cloud push. Default is ON (an absent namespace means
+ *  persistence is on, which is the shipped decision); an explicit `false` is
+ *  what turns it off. Nothing secret lives here, so no encryption. */
+const MEMORY_PERSIST_NAMESPACE = '__memoryPersist';
+
 /** Namespaces the provider-config surface must never see or mutate. */
 const RESERVED_NAMESPACES = Object.freeze([
   AEGIS_KEY_NAMESPACE,
   LEGACY_AEGIS_NAMESPACE,
   QUICK_LAUNCHER_NAMESPACE,
   CONFIRM_MODE_NAMESPACE,
+  MEMORY_PERSIST_NAMESPACE,
 ]);
 
 /** True for the AEGIS-key namespace(s) — provider CRUD must refuse these. */
@@ -282,6 +291,36 @@ function createSettingsStore({ dir, safeStorage } = {}) {
     return getConfirmMode();
   }
 
+  // --- Persisting memory: reserved namespace, plain preference -------------
+  // The desktop's half of "persisting memory for every account": whether a
+  // finished turn is pushed to cloud memory automatically. ON when unset —
+  // an install that never touched the toggle behaves like cli/, whose
+  // `memoryPersist` also defaults to on. `memoryPersistState()` reports the
+  // SOURCE as well as the value so "off" and "never set" stay distinguishable;
+  // lib/sync/persist-gate.js reads the same namespace straight off disk, and
+  // the two must agree on the default.
+
+  function getMemoryPersist() {
+    const cfg = load()[MEMORY_PERSIST_NAMESPACE] || {};
+    return cfg.enabled === undefined ? true : Boolean(cfg.enabled);
+  }
+
+  /** `{ enabled, source }` — mirrors cli/src/cloudsync.js memoryPersistState(). */
+  function memoryPersistState() {
+    const cfg = load()[MEMORY_PERSIST_NAMESPACE] || {};
+    return {
+      enabled: getMemoryPersist(),
+      source: cfg.enabled === undefined ? 'default' : 'config',
+    };
+  }
+
+  function setMemoryPersist(enabled) {
+    const data = load();
+    data[MEMORY_PERSIST_NAMESPACE] = { enabled: Boolean(enabled) };
+    save(data);
+    return memoryPersistState();
+  }
+
   return {
     file,
     get,
@@ -299,6 +338,9 @@ function createSettingsStore({ dir, safeStorage } = {}) {
     setQuickLauncherConfig,
     getConfirmMode,
     setConfirmMode,
+    getMemoryPersist,
+    memoryPersistState,
+    setMemoryPersist,
   };
 }
 
@@ -308,6 +350,7 @@ module.exports = {
   LEGACY_AEGIS_NAMESPACE,
   QUICK_LAUNCHER_NAMESPACE,
   CONFIRM_MODE_NAMESPACE,
+  MEMORY_PERSIST_NAMESPACE,
   DEFAULT_QUICK_LAUNCHER_SHORTCUT,
   RESERVED_NAMESPACES,
   isReservedNamespace,

package/lib/sync/persist-gate.js

@@ -0,0 +1,120 @@
+'use strict';
+
+/**
+ * persist-gate.js — the desktop half of "persisting memory for every account".
+ *
+ * `cli/` flips this default in config.json (`memoryPersist`, migrated off the
+ * legacy `cloudSync` key). The desktop has no config.json, so its preference
+ * lives in the same settings.json the Settings pane already writes, under the
+ * reserved `__memoryPersist` namespace — and it is read HERE, from disk, by the
+ * main process that performs the push.
+ *
+ * Two reasons the gate is not taken from the renderer:
+ *
+ *  1. The decision has to be enforceable in the main process whatever the
+ *     renderer believes. A renderer-held flag is a suggestion; the process
+ *     that opens the socket decides.
+ *  2. `createSyncDispatch()` / createAutoPush() are unit-tested in plain Node,
+ *     where no renderer and no Electron exist.
+ *
+ * Default is ON, matching cli/. `source` keeps "the user turned this off" and
+ * "nobody has been asked yet" tellable apart — the whole point of shipping a
+ * default is that the absence of a stored key is not the same as a stored no.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { MEMORY_PERSIST_NAMESPACE, SETTINGS_FILE } = require('../settings.js');
+
+/** The settings file the store writes (`createSettingsStore` uses the same
+ *  `path.join(dir, SETTINGS_FILE)`, so both agree on one source of truth).
+ *  A caller that already holds the file path may pass it directly. */
+function settingsFile(dir) {
+  const p = dir || '';
+  return p.endsWith(SETTINGS_FILE) ? p : path.join(p, SETTINGS_FILE);
+}
+
+function readSettings(dir) {
+  try {
+    const data = JSON.parse(fs.readFileSync(settingsFile(dir), 'utf8'));
+    return data && typeof data === 'object' ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * `{ enabled, source }`. `source` is 'config' only when the file actually
+ * carries the key — an explicit `false` survives, an absent namespace is ON.
+ */
+function gateState(dir) {
+  const cfg = readSettings(dir)[MEMORY_PERSIST_NAMESPACE];
+  if (!cfg || cfg.enabled === undefined) return { enabled: true, source: 'default' };
+  return { enabled: Boolean(cfg.enabled), source: 'config' };
+}
+
+/**
+ * The post-turn push, gated.
+ *
+ * `push` is `createSyncDispatch`'s own drain, so this inherits the queue
+ * fallback for free: a push flushes `memory-queue.json` before it touches the
+ * session list, which is exactly the "offline now, sync later" behaviour the
+ * manual button had and the automatic path must not lose.
+ *
+ * Coalesced: a turn that ends while a drain is still in flight does not open a
+ * second one. `push()` snapshots `sessions.listPending(dir)`, so a concurrent
+ * call would race the same rows; the newest session instead goes out on the
+ * next trigger (the following turn's auto push, or "Sync now"). One turn of
+ * delay is the correct trade against two writers marking the same session
+ * synced.
+ */
+function createAutoPush({ push, dir, gate } = {}) {
+  if (typeof push !== 'function') throw new Error('createAutoPush requires a push()');
+  const readGate = typeof gate === 'function' ? gate : () => gateState(dir);
+  let inFlight = null;
+
+  async function run() {
+    const state = readGate();
+    if (!state.enabled) {
+      return {
+        ok: true,
+        skipped: true,
+        gate: state,
+        reason: 'persisting memory is off',
+      };
+    }
+    try {
+      const result = await push();
+      return Object.assign({}, result, { skipped: false, gate: state });
+    } catch (err) {
+      // A chat turn must never fail because a background push did. `push()`
+      // already resolves `{ ok:false, … }` for its expected failures; this
+      // catches the unexpected so the caller's fire-and-forget cannot become
+      // an unhandled rejection.
+      return {
+        ok: false,
+        skipped: false,
+        gate: state,
+        reason: (err && err.message) || String(err),
+      };
+    }
+  }
+
+  function auto() {
+    if (inFlight) return inFlight;
+    inFlight = run().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  }
+
+  return { auto, gate: () => readGate(), state: () => readGate() };
+}
+
+module.exports = {
+  settingsFile,
+  readSettings,
+  gateState,
+  createAutoPush,
+};