aegis-desktop 0.6.0 → 0.7.0

package/lib/local/session-rounds.js

@@ -0,0 +1,205 @@
+'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, 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
+ *     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.
+ *
+ * `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, messages, added } = {}, 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,
+    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);
+  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/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,
+};

package/main.js

@@ -66,6 +66,7 @@ const ollama = require('./lib/local/ollama.js');
 const providers = require('./lib/local/providers.js');
 const sessionStore = require('./lib/sync/sessions.js');
 const memoryQueue = require('./lib/sync/memory-queue.js');
+const persistGate = require('./lib/sync/persist-gate.js');
 const windowState = require('./lib/window-state.js');
 const deepLink = require('./lib/deep-link.js');
 const quickLauncherLib = require('./lib/quick-launcher.js');
@@ -829,6 +830,62 @@ function createEngine(aegis, { app, safeStorage, dir: dirOverride, sessionsDir:
   return { engine, sessionsDir, settingsDir, settings };
 }
 
+/** Largest pre-edit read the diff bridge will hand the renderer (bytes). */
+const PREVIEW_READ_MAX_BYTES = 512 * 1024;
+
+/**
+ * The contained, capped read behind the renderer's diff preview — the only
+ * filesystem capability the renderer has, and the narrowest form of it.
+ *
+ * The renderer supplies a file plus the cwd of the session it is displaying.
+ * Every path is resolved with `realpath` *before* the containment test, so a
+ * symlink planted inside the workspace cannot point the read outside it, and
+ * containment is judged with `path.relative` rather than a `startsWith` prefix
+ * (which would let `/home/neo-evil` pass a naive `/home/neo` check). Anything
+ * refused — relative cwd, escape, missing file, directory, non-regular file —
+ * returns null, which degrades the preview to a create-style diff instead of
+ * throwing onto the render path.
+ *
+ * @returns {{text: string, truncated: boolean}|null}
+ */
+function readTextFileForPreview(payload) {
+  try {
+    const file = payload && typeof payload.file === 'string' ? payload.file : '';
+    const cwd = payload && typeof payload.cwd === 'string' ? payload.cwd : '';
+    if (!file || !cwd || !path.isAbsolute(cwd)) return null;
+
+    // realpath both sides: resolving the root too keeps this correct on hosts
+    // where the workspace itself is reached through a symlink (/tmp, /var).
+    const root = fs.realpathSync(cwd);
+    const abs = fs.realpathSync(path.resolve(root, file));
+    const rel = path.relative(root, abs);
+    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+
+    const st = fs.statSync(abs);
+    if (!st.isFile()) return null;
+
+    if (st.size <= PREVIEW_READ_MAX_BYTES) {
+      return { text: fs.readFileSync(abs, 'utf8'), truncated: false };
+    }
+    // Oversized: read only the head of the file and cut back to the last
+    // newline, so a byte-boundary truncation cannot leave a half-decoded
+    // multi-byte sequence at the end of the preview.
+    const fd = fs.openSync(abs, 'r');
+    try {
+      const buf = Buffer.alloc(PREVIEW_READ_MAX_BYTES);
+      const n = fs.readSync(fd, buf, 0, PREVIEW_READ_MAX_BYTES, 0);
+      let text = buf.toString('utf8', 0, n);
+      const nl = text.lastIndexOf('\n');
+      if (nl > 0) text = text.slice(0, nl + 1);
+      return { text, truncated: true };
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Pure mapping: model:<name> -> LocalEngine call (unit-testable in Node).
  */
@@ -849,6 +906,14 @@ function createModelDispatch(engine) {
       }),
     'settings.remove': (payload) =>
       engine.settings.remove(payload && payload.provider),
+    // Persisting memory ("sync finished turns to cloud memory automatically").
+    // Reserved namespace, so it is invisible to the provider CRUD above — but
+    // unlike a provider it IS reachable deliberately, through these two. The
+    // gate that enforces it lives in lib/sync/persist-gate.js and reads the
+    // same file, so a `false` written here stops the next automatic push.
+    'memoryPersist.get': () => engine.settings.memoryPersistState(),
+    'memoryPersist.set': (payload) =>
+      engine.settings.setMemoryPersist(Boolean(payload && payload.enabled)),
     cancel: (payload) => engine.cancel(payload && payload.sessionId),
     // Tool-call approval gate (desktop/lib/local/engine.js gatedExecuteTool):
     // the renderer's approval card answers a pending exec/writeFile/editFile
@@ -869,7 +934,7 @@ function createModelDispatch(engine) {
  * resolve `{ ok: false, reason }` without ever throwing, and every local
  * flow (save/append/list) keeps working untouched.
  */
-function createSyncDispatch(sessions, dir, aegis) {
+function createSyncDispatch(sessions, dir, aegis, settingsDir) {
   let lastSyncAt = null;
 
   function hasCloud() {
@@ -1013,7 +1078,20 @@ function createSyncDispatch(sessions, dir, aegis) {
     }
   }
 
+  // The automatic post-turn push (persisting memory for every account). Gated
+  // by the `__memoryPersist` preference in settings.json, which the Settings
+  // pane writes through the memoryPersist:* IPC below; the gate is read from
+  // disk in the main process so the renderer cannot push past it. This must
+  // read `settingsDir` (Electron's userData path), NOT `dir` — `dir` here is
+  // the shared aegisHome() sessions/credentials directory, a different path
+  // from userData in a real install, and the settings store is created with
+  // `settingsDir`. Falling back to `dir` only covers callers (tests) that
+  // never pass `settingsDir` and use one directory for everything.
+  const autoPush = persistGate.createAutoPush({ push, dir: settingsDir || dir });
+
   return {
+    auto: () => autoPush.auto(),
+    memoryPersistState: () => autoPush.gate(),
     listSessions: () => ({ sessions: sessions.listSessions(dir) }),
     open: (payload) => sessions.getSession(dir, payload && payload.sessionId),
     save: (payload) => sessions.upsertSession(dir, payload || {}),
@@ -1135,11 +1213,16 @@ function createHeartbeatRetry(push, opts = {}) {
  * `onReplyFinished`, like the identical param on registerIpc, is
  * bootstrap()-only — it fires the native "reply ready" notification when the
  * window is unfocused/hidden and is never set in the headless test path.
- * `heartbeatOpts` ({ now, baseMs, maxMs }) is for tests only.
+ * `heartbeatOpts` ({ now, baseMs, maxMs }) is for tests only. `settingsDir`
+ * is Electron's userData path — where settings.json (and so the
+ * `__memoryPersist` preference the auto-push gate reads) actually lives;
+ * `sessionsDir` is the separate shared aegisHome() directory and must not be
+ * used for that gate. Falls back to `sessionsDir` for callers that don't pass
+ * it, i.e. tests that use one directory for everything.
  */
-function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished, heartbeatOpts) {
+function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished, heartbeatOpts, settingsDir) {
   const modelDispatch = createModelDispatch(engine);
-  const syncDispatch = createSyncDispatch(sessionStore, sessionsDir, aegis);
+  const syncDispatch = createSyncDispatch(sessionStore, sessionsDir, aegis, settingsDir);
 
   const heartbeat = createHeartbeatRetry(() => syncDispatch.push(), heartbeatOpts);
 
@@ -1187,6 +1270,17 @@ function registerModelIpc(ipcMain, engine, sessionsDir, aegis, onReplyFinished,
     ipcMain.handle(`${MODEL_PREFIX}${name}`, (_event, payload) => handler(payload));
   }
 
+  // Diff-preview pre-edit read (preload.js `readTextFile`). Registered with
+  // `on` + `event.returnValue`, NOT `handle`: the bridge is `sendSync` because
+  // editPreview consumes its reader synchronously and cannot await an invoke
+  // promise, and `sendSync` is answered only by an `ipcMain.on` listener.
+  // Putting it in modelDispatch above would register a `handle` that sendSync
+  // never reaches. Fires on every edit tool's run frame, so the refusal path
+  // is the common case (a `writeFile` creating a new file) and must stay cheap.
+  ipcMain.on(`${MODEL_PREFIX}readTextFile`, (event, payload) => {
+    event.returnValue = readTextFileForPreview(payload);
+  });
+
   for (const [name, handler] of Object.entries(syncDispatch)) {
     if (name === 'status') {
       ipcMain.handle(`${SYNC_PREFIX}${name}`, (_event, payload) => {
@@ -1357,6 +1451,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 +1484,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 +1500,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',
       },
@@ -2163,7 +2275,7 @@ function bootstrap() {
   // One settings store backs both the provider settings surface and the AEGIS
   // API key entry. It lives only in the main process and encrypts keys at rest
   // via Electron safeStorage (best-effort base64 when unavailable).
-  const { engine, sessionsDir, settings } = createEngine(aegis, {
+  const { engine, sessionsDir, settingsDir, settings } = createEngine(aegis, {
     app,
     safeStorage,
     dir: dataDir,
@@ -2215,7 +2327,15 @@ function bootstrap() {
     (url) => shell.openExternal(url),
     notifyReplyIfUnfocused
   );
-  registerModelIpc(ipcMain, engine, sessionsDir, aegis, notifyReplyIfUnfocused);
+  registerModelIpc(
+    ipcMain,
+    engine,
+    sessionsDir,
+    aegis,
+    notifyReplyIfUnfocused,
+    undefined,
+    settingsDir
+  );
 
   // Tool-call approval toggle (Settings → "Confirm before running tools"):
   // aegis:getConfirmMode / aegis:setConfirmMode. Registered here because this
@@ -2593,6 +2713,8 @@ module.exports = {
   taggedChunk,
   maskKey,
   createModelDispatch,
+  readTextFileForPreview,
+  PREVIEW_READ_MAX_BYTES,
   createSyncDispatch,
   registerModelIpc,
   createHeartbeatRetry,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "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/diff.js && node --check renderer/diffview.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",
@@ -39,6 +39,8 @@
     "test:highlight": "node ../test/aegis-highlight.test.mjs",
     "test:markdown": "node ../test/markdown.test.mjs",
     "test:deep-link": "node test/deep-link.test.mjs",
+    "test:renderer-diff": "node test/renderer-diff.test.mjs",
+    "test:preview-read": "node ../test/desktop-preview-read.test.mjs",
     "test:stream-policy": "node ../test/stream-policy.test.mjs",
     "test:renderer-dom": "node ../test/renderer-dom.test.mjs",
     "test:renderer-wiring": "node ../test/renderer-wiring.test.mjs"