aegis-desktop 0.8.35 → 1.0.0

package/main.js

@@ -182,6 +182,14 @@ const localTools = require('./lib/local/tools.js');
 // the `queue:` IPC surface registered by registerQueueIpc() below.
 const queueModule = require('./lib/local/queue.js');
 const autonomousModule = require('./lib/local/autonomous.js');
+// Auto mode's round-horizon half: the same arithmetic the upstream engine
+// (aegiscodex-dev src/autonomous.js) and the CLI's presenter use, read here by
+// the one host that owns this face's policy. See createModelDispatch.
+const {
+  autoContinuePlan,
+  autoContinueLimit,
+  autoRoundsDefault,
+} = require('./lib/local/autonomous.js');
 
 // The Pro boundary for the autonomous queue (Phase 4 of
 // docs/upgrade-conversion-plan.md). MAIN-process only, no Electron inside, so
@@ -1078,7 +1086,34 @@ function createConfirmModeDispatch(settings) {
   };
 }
 
-/** Register getConfirmMode/setConfirmMode as `aegis:<name>` on ipcMain —
+/**
+ * Auto mode's other switch: a posture of "don't ask" IS auto mode on this face,
+ * so an explicit setConfirmMode must move the model dispatch's session state
+ * with it. Otherwise the two halves of the mode can be told different things —
+ * the engine stops asking, the round horizon keeps raising its card, and the
+ * chip in the composer claims auto mode is on.
+ *
+ * OFF starts auto mode for this sitting (`setAutoRounds(true)`, which also
+ * retires a boot-time AEGIS_AUTO_ROUNDS=0), ON ends it. A malformed payload
+ * changes nothing, exactly as in createConfirmModeDispatch — including the
+ * session state, so the two cannot drift on a bad message.
+ */
+function withAutoRoundsSwitch(confirmDispatch, modelDispatch) {
+  const setConfirmMode = confirmDispatch.setConfirmMode;
+  return {
+    ...confirmDispatch,
+    setConfirmMode: (payload) => {
+      const res = setConfirmMode(payload);
+      if (payload && typeof payload.enabled === 'boolean' && modelDispatch && typeof modelDispatch.setAutoRounds === 'function') {
+        modelDispatch.setAutoRounds(payload.enabled === false);
+      }
+      return res;
+    },
+  };
+}
+
+/**
+ * Register getConfirmMode/setConfirmMode as `aegis:<name>` on ipcMain —
  *  the same ${IPC_PREFIX}<method> convention registerIpc uses for the rest of
  *  the renderer's aegis.* bridge (their handlers need nothing but the
  *  payload, so the event is dropped exactly like every non-chatCompletion
@@ -1398,11 +1433,149 @@ function readTextFileForPreview(payload) {
 /**
  * Pure mapping: model:<name> -> LocalEngine call (unit-testable in Node).
  */
-function createModelDispatch(engine) {
-  return {
+function createModelDispatch(engine, { env = process.env, settings } = {}) {
+  // ── Auto mode's second half: the round horizon ────────────────────────────
+  //
+  // autoContinuePlan/autoContinueLimit (lib/local/autonomous.js) answer "may
+  // this horizon ask be answered for the user?" — the arithmetic the engine
+  // defines in src/autonomous.js and the ONLY thing separating auto mode in
+  // aegiscodex-dev from auto mode here. The desktop wired the first half (no
+  // approval cards, via the Tool-approvals switch) and nothing at all for this
+  // one, so a desktop turn that hit its round horizon raised the blocking card
+  // on the first hit and every hit after it. That is the exact question auto
+  // mode exists to stop asking: same answer, same click, once per horizon.
+  //
+  // The policy lives HERE rather than in the engine on purpose — the engine's
+  // own comment states the contract ("the hook is optional and the caller owns
+  // the policy"), so the engine keeps asking and each host decides. This host's
+  // answer is the posture the user already set in one place: confirmations OFF
+  // (the same boolean behind the settings switch and the composer's "auto mode"
+  // chip) means auto mode is on, and the tally is per session because that is
+  // the lifetime of the turn it is funding.
+  const autoUsed = new Map(); // sessionId -> automatic continuations spent
+
+  // Auto mode's session START state — the engine's AEGIS_AUTO_ROUNDS=0 opt-out
+  // (src/autonomous.js autoRoundsDefault), read once here rather than on every
+  // call. Re-derived per call it is a VETO, not a start state: with the variable
+  // exported in the environment that launched the app, the Tool-approvals switch
+  // and any `/automode on` from the CLI sharing the store would write the
+  // posture and change nothing — the chip lit, the round card still every
+  // horizon, and no way back to auto mode short of restarting the app. The
+  // engine's own contract is the other one: the env var picks where the session
+  // STARTS, and the toggle moves it freely from there.
+  //
+  // The opt-out is retired by an explicit act, of which there are two here:
+  // setAutoRounds (the switch and the IPC, wired at bootstrap) and a stored
+  // posture that differs from the one this process booted with (a flip made by
+  // another face — the CLI's `/automode` writes the same key).
+  let autoRoundsSession = autoRoundsDefault(env);
+  let bootPosture;
+  let autoRoundsRetired = false;
+
+  /** True only when auto mode is on: the session state AND a posture that says
+   *  don't ask. Read per call, never captured: the settings
+   *  switch and `/automode` in the CLI both write the same shared key, so a
+   *  flip takes effect on the next horizon without a restart.
+   *
+   *  `undefined` from every accessor means "this store cannot answer" — and an
+   *  unknown posture must NOT be read as auto mode ON: silently extending turns
+   *  (and spending billed rounds) on a store we cannot read is the worse
+   *  failure, and the pre-change behaviour (show the card) is the safe default.
+   *  AEGIS_AUTO_ROUNDS=0 turns it off session-wide, exactly as in the engine. */
+  const autoRoundsOn = () => {
+    const store = settings || (engine && engine.settings) || null;
+    const bool = (v) => (typeof v === 'boolean' ? v : undefined);
+    let posture;
+    try {
+      if (store && typeof store.confirmModeState === 'function') {
+        const st = store.confirmModeState();
+        posture = bool(st && st.enabled);
+      }
+      if (posture === undefined && store && typeof store.getConfirmMode === 'function') {
+        posture = bool(store.getConfirmMode());
+      }
+    } catch {
+      /* an unreadable store is not auto mode — the card stays up */
+    }
+    // A posture that moved since boot means somebody acted (another face wrote
+    // the same key), so the env opt-out has been answered and no longer applies.
+    if (!autoRoundsRetired && posture !== undefined) {
+      if (bootPosture === undefined) bootPosture = posture;
+      else if (posture !== bootPosture) {
+        autoRoundsRetired = true;
+        autoRoundsSession = true;
+      }
+    }
+    if (!autoRoundsSession || !store || posture === undefined) return false;
+    return posture === false;
+  };
+
+  /** Move the session state — the switch (via setConfirmMode at bootstrap) and
+   *  any explicit auto-mode request. Turns OFF means the operator asked for
+   *  manual NOW, so it sticks against the boot-time opt-out in both
+   *  directions. */
+  const setAutoRounds = (v) => {
+    autoRoundsSession = Boolean(v);
+    autoRoundsRetired = true;
+  };
+
+  /**
+   * Wrap the renderer's stream so a round-horizon ask can be answered for the
+   * human while auto mode is on, and forwarded untouched otherwise.
+   *
+   * Three things are load-bearing:
+   *
+   *   · the ENGINE is what answers (`respondRoundsAsk`), not a synthetic frame
+   *     — the turn is held open on that promise, so the only honest way to skip
+   *     the dialog is to resolve it;
+   *   · `{ note }` reaches the renderer, because a budget that grew invisibly
+   *     is the "why is it still running?" report, and the CLI announces this
+   *     same continuation through its transcript note;
+   *   · a declined/failed answer FALLS THROUGH to the card. The allowance is
+   *     spent, so this is the real ask — the same "then it asks" contract the
+   *     CLI and the engine's status line advertise.
+   */
+  const chatWithAutoRounds = (payload) => {
+    const forward = payload && payload.onStream;
+    if (typeof forward !== 'function') return engine.chat(payload, forward);
+    const sessionId = (payload && payload.sessionId) || '';
+    const onStream = (chunk) => {
+      if (chunk && chunk.rounds && chunk.rounds.id && autoRoundsOn()) {
+        const plan = autoContinuePlan({
+          on: true,
+          used: autoUsed.get(sessionId) || 0,
+          limit: autoContinueLimit(env),
+        });
+        autoUsed.set(sessionId, plan.used);
+        if (plan.auto) {
+          const answered =
+            typeof engine.respondRoundsAsk === 'function'
+              ? engine.respondRoundsAsk(chunk.rounds.id, true)
+              : { ok: false };
+          if (answered && answered.ok) {
+            const spent = Number(chunk.rounds.spent) || 0;
+            forward({
+              note:
+                `auto mode: the ${spent}-round limit was reached — continuing automatically ` +
+                `(${plan.used}/${plan.cap}, then it asks).`,
+            });
+            return;
+          }
+        }
+        // Not auto (allowance spent, or the engine could not take an answer):
+        // show the real card. plan.used is 0 in the spent case, so the next
+        // horizon starts a fresh block of automatic continuations — the same
+        // reset the CLI's presenter applies once the human is actually asked.
+      }
+      forward(chunk);
+    };
+    return engine.chat(payload, onStream);
+  };
+
+  const dispatch = {
     listClasses: () => engine.listClasses(),
     listModels: (payload) => engine.listModels(payload && payload.class),
-    chat: (payload) => engine.chat(payload, payload && payload.onStream),
+    chat: chatWithAutoRounds,
     // The AEGIS key lives in a reserved namespace the store refuses to expose
     // or delete through this surface; the filter is belt-and-braces so a
     // mis-wired store can never hand the renderer a removable AEGIS entry.
@@ -1415,6 +1588,22 @@ function createModelDispatch(engine) {
       }),
     'settings.remove': (payload) =>
       engine.settings.remove(payload && payload.provider),
+    // The USER's own model declarations (`client/user-models.js`, the file the
+    // CLI's `/model-add` writes). Settings is the only place a desktop user can
+    // add a model the server's catalog does not name, and until this existed the
+    // only ways were a release or hand-editing a JSON file the app never named.
+    //
+    // These three go through the ENGINE rather than the settings store: the
+    // engine's `listModels('byok')` is what applies them, so the write and the
+    // read share one implementation and cannot disagree about the file. Add and
+    // remove THROW on a malformed provider/model id — the renderer shows the
+    // message, which is the honest outcome for a string that would otherwise be
+    // forwarded to a vendor and 404 there.
+    'userModels.get': () => engine.userModels(),
+    'userModels.add': (payload) =>
+      engine.addUserModel(payload && payload.provider, payload && payload.model),
+    'userModels.remove': (payload) =>
+      engine.removeUserModel(payload && payload.provider, payload && payload.model),
     // 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
@@ -1449,6 +1638,25 @@ function createModelDispatch(engine) {
     clearApprovals: (payload) =>
       engine.clearSessionApprovals(payload && payload.sessionId),
   };
+
+  // Auto mode's session state is read and moved DIRECTLY, never over IPC.
+  // Two reasons, and both are load-bearing:
+  //
+  //   · every ENUMERABLE key of this object becomes an `aegis:<name>` channel
+  //     (registerModelIpc iterates Object.entries), so exporting these would
+  //     hand the renderer a way to move auto mode's round half without moving
+  //     the posture — the exact two-answers-one-question drift this file's
+  //     dispatch exists to prevent. The renderer's switch reaches both halves
+  //     through aegis:setConfirmMode (withAutoRoundsSwitch), which is the one
+  //     act that means "auto mode" on this face;
+  //
+  //   · a signature change to the bridge has to be visible where the bridge is
+  //     described, so the count in test/model-dispatch.mjs stays a real check.
+  Object.defineProperties(dispatch, {
+    autoRoundsOn: { value: autoRoundsOn, enumerable: false },
+    setAutoRounds: { value: setAutoRounds, enumerable: false },
+  });
+  return dispatch;
 }
 
 /**
@@ -3141,7 +3349,7 @@ function bootstrap() {
     handleReplyFinished,
     () => providerRouteConfigured(engine)
   );
-  registerModelIpc(
+  const modelIpc = registerModelIpc(
     ipcMain,
     engine,
     sessionsDir,
@@ -3156,7 +3364,16 @@ function bootstrap() {
   // is where the settings store lands — the exact tool gate it controls lives
   // in the engine created alongside it (lib/local/engine.js gatedExecuteTool
   // reads settings.getConfirmMode() on every mutating tool call).
-  registerConfirmModeIpc(ipcMain, createConfirmModeDispatch(settings));
+  //
+  // …and it is also auto mode's OTHER switch: a posture of "don't ask" is what
+  // auto mode means on this face, so flipping the switch off is an explicit
+  // request for it and must move the session state with it. Without this, an
+  // app launched with AEGIS_AUTO_ROUNDS=0 (a start-manual opt-out, per the
+  // engine) could be switched to auto mode in the UI — approvals off, chip lit
+  // — while the round horizon kept raising its card, because the env var was
+  // re-read as a veto on every horizon. Same escape hatch as `/automode on` in
+  // the CLI, which shares this store.
+  registerConfirmModeIpc(ipcMain, withAutoRoundsSwitch(createConfirmModeDispatch(settings), modelIpc.modelDispatch));
 
   // Funnel instrumentation (Phase 2 of docs/upgrade-conversion-plan.md):
   // aegis:telemetryEvent / aegis:telemetryReport, backed by
@@ -3755,6 +3972,7 @@ module.exports = {
   createQuickLauncherDispatch,
   registerQuickLauncherIpc,
   createConfirmModeDispatch,
+  withAutoRoundsSwitch,
   createTelemetryDispatch,
   registerTelemetryIpc,
   createCovenantDispatch,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aegis-desktop",
   "productName": "AEGIS Desktop",
-  "version": "0.8.35",
+  "version": "1.0.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",

package/preload.js

@@ -349,6 +349,18 @@ const models = {
       }),
     remove: (provider) => invokeModel('settings.remove', { provider }),
   },
+  // The user's OWN model declarations (client/user-models.js): the file the
+  // CLI's `/model-add` writes, reached here so a model the server's catalog
+  // does not name can be added from Settings instead of by hand. `get()`
+  // resolves `{ dir, file, map, invalid }` — `file` is shown in the UI so the
+  // remaining escape hatch (an editor) is discoverable, and `invalid` names any
+  // hand-edited row that was skipped. `add`/`remove` reject with the validation
+  // message for a malformed provider or model id.
+  userModels: {
+    get: () => invokeModel('userModels.get'),
+    add: (provider, model) => invokeModel('userModels.add', { provider, model }),
+    remove: (provider, model) => invokeModel('userModels.remove', { provider, model }),
+  },
   cancel: (sessionId) => invokeModel('cancel', { sessionId }),
   // Tool-call approval gate: the renderer's approval card calls this to
   // answer a pending exec/writeFile/editFile request (the approval itself

package/renderer/app.js

@@ -3608,6 +3608,30 @@ function renderApprovalCard(row, approval, beforeSelector) {
   return card;
 }
 
+/**
+ * A turn-level note written by the APP, not by the model (`onDelta`'s
+ * `{ note }` chunk). Rendered inside the assistant row it belongs to, above the
+ * text stream, and kept out of `streamedText` for the reason the branch that
+ * calls this states: the row's text is persisted as the assistant's own message
+ * and pushed to the account's cloud memory, so app-authored prose placed there
+ * would come back on the next turn as the model's previous answer.
+ *
+ * It exists because auto mode's silent round continuations have to be VISIBLE:
+ * a turn whose budget quietly grew is the "why is it still running?" report
+ * this app keeps getting, and the CLI announces the same continuation with the
+ * same wording in its transcript.
+ */
+function appendTurnNote(row, text, beforeSelector) {
+  if (!row || !text) return null;
+  const note = document.createElement('div');
+  note.className = 'turn-note';
+  note.textContent = text;
+  const before = beforeSelector ? row.querySelector(beforeSelector) : null;
+  if (before) row.insertBefore(note, before);
+  else row.appendChild(note);
+  return note;
+}
+
 /**
  * Render the round-horizon card (`onDelta`'s `{ rounds: { id, spent,
  * extensions, max, size } }` chunk — see `requestRoundsAsk` in
@@ -4160,6 +4184,12 @@ async function saveLocalBase(baseURL) {
 
 async function loadSettings() {
   els.settingsList.innerHTML = '';
+  // The provider ids the class offers, collected while the byok rows are built.
+  // `/byok`'s own list IS the catalog, so the "add a model" field below can
+  // offer it instead of asking the user to remember a slug — and it can still
+  // accept a typed id, because the very case this row exists for is a provider
+  // whose lineup moved ahead of our catalog.
+  const byokProviderIds = [];
   let settings = [];
   try {
     settings = (await models.settings.get()) || [];
@@ -4198,6 +4228,7 @@ async function loadSettings() {
     const byokProviders = Array.isArray(byokData && byokData.providers) ? byokData.providers : [];
     for (const p of byokProviders) {
       if (!p || !p.id) continue;
+      byokProviderIds.push({ id: p.id, label: p.label || p.id });
       const provider = `byok:${p.id}`;
       const local = settings.find((s) => s.provider === provider) || {
         provider, baseURL: '', configured: false, keyMask: null,
@@ -4234,6 +4265,195 @@ async function loadSettings() {
   } catch {
     /* catalog unreachable (offline, server down) — no rows, and the hint above says why */
   }
+
+  // The user's OWN model declarations (`client/user-models.js`, the file the
+  // CLI's `/model-add` writes). Rendered outside the byok try above so it
+  // survives an unreachable catalog, and it is the ONE way a desktop user can
+  // pin a model the AEGIS catalog does not name — a newly shipped vendor id, a
+  // fine-tune, a preview route — without waiting for a release or hand-editing
+  // a JSON file the app never named. The relay is a pass-through, so anything
+  // the vendor serves for a provider whose key is set is callable.
+  try {
+    await renderUserModelRows(byokProviderIds);
+  } catch (err) {
+    els.settingsHint.textContent =
+      `your own models: ${err && err.message ? err.message : err}`;
+  }
+}
+
+/**
+ * The "your own models" block: one add row plus a row per declaration.
+ *
+ * Everything here goes through the engine (`models.userModels.*`), never
+ * through the settings store, because the engine's `listModels('byok')` is what
+ * APPLIES the declarations — one implementation writes the file and one reads
+ * it, so the row a user adds here is the row the picker offers on its next
+ * refresh (loadModels is re-run by the callers below).
+ *
+ * A rejected value does not throw into the console: `add`/`remove` reject with
+ * the validation message (an id the relay would forward to a vendor 404s on the
+ * user's first turn, so refusing it here is the whole value of the check) and it
+ * is printed in the hint line with the file path, which is also the documented
+ * escape hatch for a bulk edit.
+ */
+async function renderUserModelRows(byokProviderIds) {
+  if (!els.settingsList || !models.userModels) return;
+  const report = await models.userModels.get();
+  if (!report) return;
+  const map = (report && report.map) || {};
+  const ids = (byokProviderIds || []).map((p) => (p && p.id) || '').filter(Boolean);
+
+  const block = document.createElement('div');
+  block.id = 'user-models-block';
+
+  const title = document.createElement('div');
+  title.className = 'setting-name';
+  title.textContent = 'Your own models (BYOK)';
+  block.appendChild(title);
+
+  // ── add: provider + model id + one button
+  const addRow = document.createElement('div');
+  addRow.className = 'setting-row';
+  addRow.dataset.provider = 'byok:__user-model-add';
+
+  const providerInput = document.createElement('input');
+  providerInput.type = 'text';
+  providerInput.className = 'setting-input';
+  providerInput.id = 'user-model-provider';
+  providerInput.placeholder = 'provider (deepseek)';
+  providerInput.autocomplete = 'off';
+  providerInput.spellcheck = false;
+  // A datalist rather than a select: the catalog's ids are a convenience for the
+  // common case, and a typed slug is still allowed for the case this row exists
+  // for (the catalog has not caught up). A select would have made the second one
+  // impossible without a form of its own.
+  if (ids.length) {
+    const list = document.createElement('datalist');
+    list.id = 'user-model-providers';
+    for (const id of ids) {
+      const opt = document.createElement('option');
+      opt.value = id;
+      list.appendChild(opt);
+    }
+    addRow.appendChild(list);
+    providerInput.setAttribute('list', 'user-model-providers');
+  }
+  addRow.appendChild(providerInput);
+
+  const modelInput = document.createElement('input');
+  modelInput.type = 'text';
+  modelInput.className = 'setting-input';
+  modelInput.id = 'user-model-id';
+  modelInput.placeholder = 'model id (deepseek-v4.2-preview)';
+  modelInput.autocomplete = 'off';
+  modelInput.spellcheck = false;
+  addRow.appendChild(modelInput);
+
+  const actions = document.createElement('div');
+  actions.className = 'setting-actions';
+  const addBtn = document.createElement('button');
+  addBtn.type = 'button';
+  addBtn.className = 'ghost-btn';
+  addBtn.id = 'user-model-add';
+  addBtn.textContent = 'Add model';
+  addBtn.addEventListener('click', async () => {
+    const provider = providerInput.value.trim();
+    const model = modelInput.value.trim();
+    els.settingsHint.textContent = 'adding…';
+    try {
+      const res = await models.userModels.add(provider, model);
+      els.settingsHint.textContent = res && res.added === false
+        ? `${res.provider}:${res.model} was already declared.`
+        : `added ${res.provider}:${res.model} — /models and the picker now offer it.`;
+      await loadSettings();
+      await loadModels(els.classSelect.value);
+    } catch (err) {
+      els.settingsHint.textContent = `${err && err.message ? err.message : err}`;
+    }
+  });
+  actions.appendChild(addBtn);
+  addRow.appendChild(actions);
+
+  const hint = document.createElement('div');
+  hint.className = 'setting-status';
+  hint.id = 'user-model-hint';
+  hint.textContent = report.file
+    ? `saved in ${report.file} — the CLI reads the same file (/model-add)`
+    : 'saved beside your AEGIS config — the CLI reads the same file (/model-add)';
+  addRow.appendChild(hint);
+  block.appendChild(addRow);
+
+  // ── one removal row per declaration, provider-major and sorted, so the list
+  // is stable between renders (an order that shuffled would make the Remove
+  // button beside a row a guess).
+  const providers = Object.keys(map).sort();
+  for (const provider of providers) {
+    for (const model of map[provider]) {
+      const row = document.createElement('div');
+      row.className = 'setting-row';
+      row.dataset.provider = `byok:${provider}`;
+
+      const name = document.createElement('div');
+      name.className = 'setting-name';
+      name.textContent = `${provider} — ${model}`;
+      row.appendChild(name);
+
+      const status = document.createElement('div');
+      status.className = 'setting-status';
+      // Declared, but not offered: the server's BYOK catalog lists no row for
+      // this provider, so no key could ever be attached to it and the engine
+      // will not paint it. Saying so here is the difference between "my typo is
+      // being ignored" and "this provider cannot take a key".
+      status.textContent = ids.length && !ids.includes(provider)
+        ? 'no provider row for this id — /byok lists the ones the relay takes'
+        : 'offered in the picker on this machine';
+      row.appendChild(status);
+
+      const rowActions = document.createElement('div');
+      rowActions.className = 'setting-actions';
+      const rmBtn = document.createElement('button');
+      rmBtn.type = 'button';
+      rmBtn.className = 'ghost-btn danger';
+      rmBtn.textContent = 'Remove';
+      rmBtn.addEventListener('click', async () => {
+        els.settingsHint.textContent = 'removing…';
+        try {
+          const res = await models.userModels.remove(provider, model);
+          els.settingsHint.textContent = res && res.removed === false
+            ? `${provider}:${model} was not declared.`
+            : `removed ${provider}:${model}.`;
+          await loadSettings();
+          await loadModels(els.classSelect.value);
+        } catch (err) {
+          els.settingsHint.textContent = `${err && err.message ? err.message : err}`;
+        }
+      });
+      rowActions.appendChild(rmBtn);
+      row.appendChild(rowActions);
+
+      block.appendChild(row);
+    }
+  }
+
+  // A hand-edited file can carry a row this module refuses (a typo, an id with a
+  // space). It is named rather than dropped in silence: otherwise "my model is
+  // nowhere in the picker" has no explanation anywhere in the UI.
+  const invalid = (report && report.invalid) || [];
+  for (const bad of invalid) {
+    const row = document.createElement('div');
+    row.className = 'setting-row';
+    const name = document.createElement('div');
+    name.className = 'setting-name';
+    name.textContent = `${bad.provider || 'models.json'}: ${bad.model == null ? '' : String(bad.model)}`.trim();
+    row.appendChild(name);
+    const status = document.createElement('div');
+    status.className = 'setting-status';
+    status.textContent = `skipped — ${bad.reason}`;
+    row.appendChild(status);
+    block.appendChild(row);
+  }
+
+  els.settingsList.appendChild(block);
 }
 
 async function saveSetting(provider, key) {
@@ -4663,6 +4883,19 @@ async function send() {
       paintStream();
       return;
     }
+    if (chunk && typeof chunk.note === 'string' && chunk.note) {
+      // A turn-level notice that is NOT the model's words — today the only one
+      // is auto mode's "continuing automatically" line (desktop/main.js
+      // chatWithAutoRounds). It is deliberately not folded into
+      // `streamedText`: that string becomes the assistant's message and is
+      // persisted and synced, so an app-authored sentence put there would
+      // re-enter the model's context on the next turn as something it had said.
+      const row = ensurePendingRow();
+      row.classList.remove('pending');
+      appendTurnNote(row, chunk.note, '.body');
+      stickToBottom();
+      return;
+    }
     if (chunk && chunk.approval) {
       const row = ensurePendingRow();
       row.classList.remove('pending');

package/renderer/style.css

@@ -1543,6 +1543,20 @@ label {
   color: var(--text2);
 }
 
+/* An app-authored turn note ({ note } frames — today auto mode's "continuing
+   automatically" line). Muted and unboxed on purpose: it is a statement about
+   the turn's budget, not a question, and it must not read as either of the two
+   cards that ARE questions (approval, round horizon). */
+.turn-note {
+  font-family: var(--font-mono);
+  font-size: 11px;
+  color: var(--text2);
+  border-left: 2px solid var(--accent);
+  padding: 2px 0 2px 8px;
+  margin: 4px 0;
+  opacity: 0.9;
+}
+
 .approval-title {
   font-family: var(--font-mono);
   font-size: 11px;