aegis-desktop 1.0.13 → 1.0.15

package/main.js

@@ -1,4393 +1,6 @@
 #!/usr/bin/env node
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Copyright (C) 2026 Niklas Borneklint — AEGIS Code (aegiscode) / Aegiscloud.
-// AEGIS Code (aegiscode) — source: https://github.com/aegisinfo/aegiscode-plugin
-// Conveying a modified copy, or running one as a network service, owes the
-// corresponding source under this licence (§5/§13) — see LICENSING.md.
-/**
- * AEGIS Desktop — thin Electron main shell (host 2).
- *
- * This process owns the ONLY privileged object in the app: an instance of the
- * shared thin client (../client/aegis.js), which holds the AEGIS_API_KEY read
- * from the environment. The renderer never sees the key; it talks exclusively
- * over a whitelisted, context-isolated IPC surface (see preload.js).
- *
- * Hard boundary: this file is a window + IPC shell. It contains no engine,
- * orchestration, routing, tier, or memory logic — that all lives behind
- * aegiscloud.org. If it grows beyond a thin shell, it is wrong.
- *
- * Layout:
- *   - bootstrap()      Electron-only: window + IPC registration + lifecycle
- *   - createIpcDispatch()  pure: method-name -> client call (unit-testable
- *                     in plain Node, no Electron binary needed)
- */
-
-'use strict';
-
-const path = require('node:path');
-const fs = require('node:fs');
-const { execFile } = require('node:child_process');
-const { pathToFileURL } = require('node:url');
-
-// Dev / CI / smoke-test layout: desktop/ lives inside the repo, so the shared
-// client resolves via ../client/aegis.js. In the packaged app the client is
-// copied to desktop/vendor/aegis.js by the predist step (electron-builder
-// cannot reach outside the app dir), so fall back to that copy. Both files
-// are the same thin transport — never brain logic.
-let sharedClient;
-try {
-  sharedClient = require('../client/aegis.js');
-} catch {
-  sharedClient = require('./vendor/aegis.js');
-}
-const { createClient } = sharedClient;
-
-// The shared credential store (`client/credentials.js`) — the same 0600 file
-// the terminal host writes with `aegiscode login` and the MCP plugin reads. The
-// app resolves its own account key through it, so signing in once serves all
-// four hosts; see resolveStartupKey() and persistApiKey() below.
-let credentials;
-try {
-  credentials = require('../client/credentials.js');
-} catch {
-  credentials = require('./vendor/credentials.js');
-}
-
-// Same auto-provision helper the MCP plugin and the CLI use (see
-// client/auto-provision.js) — one implementation so all three hosts ask
-// aegis1 for the same account on the same machine, with the same timeout.
-let autoProvision;
-try {
-  autoProvision = require('../client/auto-provision.js');
-} catch {
-  autoProvision = require('./vendor/auto-provision.js');
-}
-
-// The shared presence beacon (client/presence.js) — the client half of
-// aegis1's `/api/v1/heartbeat` (app.py `heartbeat_v1`), which writes the
-// `client_presence` row the admin panel's presence card reads. Started once the
-// account key is known (see the beacon block in `app.whenReady`), stopped in
-// `will-quit`. Same file the CLI beacons through, so the panel sees one
-// vocabulary (`app: 'desktop'` / `'aegiscode'`) and not two.
-let sharedPresence;
-try {
-  sharedPresence = require('../client/presence.js');
-} catch {
-  sharedPresence = require('./vendor/presence.js');
-}
-
-// The shared top-up core (client/topup.js) — the same module the terminal host
-// drives from `aegiscode topup`. It owns the amount bounds, the payload reading
-// and the credit-watch state machine; this host owns only the TIMER (below) and
-// the notification, because the window stays open for a payment that may never
-// complete. Resolved through the same two-layout require as every other shared
-// module: the repo checkout has ../client/, the packaged app has ./vendor/.
-let sharedTopup;
-try {
-  sharedTopup = require('../client/topup.js');
-} catch {
-  sharedTopup = require('./vendor/topup.js');
-}
-
-// Google identity + Drive (client/google-signin.js, client/drive-connect.js,
-// client/drive-upload.js). google-signin.js already existed for the CLI's
-// `connect --google`; this is the first time desktop wires any of it. See
-// lib/google-connect.js for how the three are sequenced.
-let googleSignIn;
-try {
-  googleSignIn = require('../client/google-signin.js');
-} catch {
-  googleSignIn = require('./vendor/google-signin.js');
-}
-let driveConnectLib;
-try {
-  driveConnectLib = require('../client/drive-connect.js');
-} catch {
-  driveConnectLib = require('./vendor/drive-connect.js');
-}
-let driveUploadLib;
-try {
-  driveUploadLib = require('../client/drive-upload.js');
-} catch {
-  driveUploadLib = require('./vendor/drive-upload.js');
-}
-const { createGoogleConnect } = require('./lib/google-connect.js');
-
-// The device fingerprint (client/device-fingerprint.js) — the SAME identity the
-// auto-provision path registers a device-key against, now also carried in every
-// presence beat so one laptop is one machine in the admin panel rather than one
-// row per launch. Resolved here rather than left to presence.js's own fallback
-// for the same reason the CLI resolves it at its call site: a host that cannot
-// state its identity should fail visibly, not substitute a different one.
-let sharedFingerprint;
-try {
-  sharedFingerprint = require('../client/device-fingerprint.js');
-} catch {
-  sharedFingerprint = require('./vendor/device-fingerprint.js');
-}
-
-// φ(α): the authorship key and sealed session records (lib/fingerprint.js).
-// The service is built with the app's own data dir, so the key it mints is the
-// key `aegiscode fingerprint` resolves in the terminal — one identity, two
-// hosts, no second store. Everything cryptographic lives in the shared client
-// modules it loads; this require only wires the IPC surface in registerIpc()
-// below (`fingerprintStatus`/`keygen`/`mint`/`verify`/`backup`).
-const { createFingerprintService } = require('./lib/fingerprint.js');
-
-// The two background automations (lib/auto.js): the auto-drain timer and the
-// seal-on-quiet auto-mint. Both are DEFAULT ON — the queue and the seal run
-// with no click and no card on the desktop — and both read their switch from
-// the settings store's reserved `__autoDrain`/`__autoMint` namespaces on every
-// tick, so this require wires the TIMING only: the queue worker still owns the
-// lock and lib/fingerprint.js still owns the seal. An explicit `enabled: false`
-// in the settings store is what stops either one, and stopping it takes effect
-// on the very next tick.
-const { createAutoDrain, createAutoMint } = require('./lib/auto.js');
-
-// The shared `~/.aegiscode/.env` loader (client/env-file.js, staged to
-// ./vendor/env-file.js when packaged). It is what makes the key instruction the
-// same in every host — "put it in ~/.aegiscode/.env" — because AEGIS_API_KEY is
-// already the first entry in the credential resolution order above and a BYOK
-// provider's key is read from the matching <PROVIDER>_API_KEY (see
-// lib/local/engine.js). Deliberately NOT called at module load: seven test
-// files require this file, and a top-level call would let the developer's own
-// env file reach a test that asserts no key is configured. bootstrap() below —
-// the real app entry — calls it instead.
-let envFile = null;
-try {
-  envFile = require('../client/env-file.js');
-} catch {
-  try {
-    envFile = require('./vendor/env-file.js');
-  } catch {
-    /* neither present: the environment is the only source, as before */
-  }
-}
-
-let electron = null;
-try {
-  // In plain Node (CI smoke test, `node --check`) this either throws
-  // (module absent) or resolves to the electron binary path string with no
-  // `.app` — either way bootstrap() is skipped and the pure exports survive.
-  electron = require('electron');
-} catch {
-  /* not running under Electron */
-}
-
-// LocalEngine wiring (plan P1 §5.2): the model:/sync: surfaces are additive,
-// backed by transport-only modules in desktop/lib/. No brain logic enters here.
-const os = require('node:os');
-const { createLocalEngine } = require('./lib/local/engine.js');
-const { createAccountKey, startupKeyOverride } = require('./lib/account-key.js');
-const { createSettingsStore, isReservedNamespace } = require('./lib/settings.js');
-const sessionStore = require('./lib/sync/sessions.js');
-const memoryQueue = require('./lib/sync/memory-queue.js');
-const persistGate = require('./lib/sync/persist-gate.js');
-// Avatar level authority. The ledger, the replay and the award
-// hooks live here in main — a renderer-held counter is a suggestion, not a
-// fact, the same reasoning persist-gate.js follows. The pure halves
-// (xp.js/level.js/events.js/persona.js) are unchanged and stay IO-free; store.js
-// is the only file in lib/avatar/ that touches a disk.
-const avatarStore = require('./lib/avatar/store.js');
-const windowState = require('./lib/window-state.js');
-const deepLink = require('./lib/deep-link.js');
-const quickLauncherLib = require('./lib/quick-launcher.js');
-// Foreign-memory scanner (shared with client/foreign-memory.js). Same
-// resolution rule as the transport above: the canonical file inside the repo,
-// the predist-staged copy in a packaged app. Never forked logic — so it needs
-// no wrapper module of its own.
-let foreignMemory;
-try {
-  foreignMemory = require('../client/foreign-memory.js');
-} catch {
-  foreignMemory = require('./vendor/foreign-memory.js');
-}
-// Builtin tool executor for the agent loop (client half of the upstream engine's
-// tool calling). MAIN-process only: it is reachable from the renderer solely
-// through the whitelisted `tools:` IPC surface registered below — see the
-// sandbox note on registerToolsIpc().
-const localTools = require('./lib/local/tools.js');
-
-// The local autonomous work queue (commit 96fb64f): a durable task list plus
-// the unattended worker that drives the local engine's tool loop. MAIN-process
-// only, like the tool executor above — the renderer reaches it solely through
-// 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
-// the gate — including the bypass path — is unit-testable in plain Node:
-// desktop/test/queue-entitlement.test.mjs.
-const entitlementModule = require('./lib/local/entitlement.js');
-
-// Funnel instrumentation (Phase 2 of docs/upgrade-conversion-plan.md): the
-// allowlist, the opt-in gate and the local-first sink for the two events the
-// renderer emits. MAIN-process only — the renderer reaches it solely through
-// `aegis:telemetryEvent` (see createTelemetryDispatch below), and the module
-// imports no Electron so it is unit-testable in plain Node.
-const telemetryModule = require('./lib/local/telemetry.js');
-const covenantModule = require('./lib/local/covenant.js');
-const { createTelemetry, telemetryEnabled } = telemetryModule;
-
-const IPC_PREFIX = 'aegis:';
-const MODEL_PREFIX = 'model:';
-const SYNC_PREFIX = 'sync:';
-const TOOLS_PREFIX = 'tools:';
-const QUICK_PREFIX = 'quick:';
-const QUEUE_PREFIX = 'queue:';
-const AUTO_PREFIX = 'auto:';
-
-/**
- * The model classes THIS face offers in its pickers, in registry order.
- *
- * Narrower than the engine's `CLASSES` registry on purpose. The engine is
- * shared with the CLI (`cli/src/deps.js` requires this same file), so a class
- * is added or removed once, in `engine.js`, for both hosts — and the CLI does
- * ship `pro` (the user's own Claude Code subscription, spawned through the
- * `claude` binary). This face does not: the Pro transport hands the turn to a
- * headless child that runs its own agent loop and its own permission prompts,
- * and this window has no channel to answer those prompts, so selecting it here
- * is a class a user can pick and then watch do nothing. Omitted rather than
- * listed-and-broken.
- *
- * Filtering HERE rather than in the registry is the same move the CLI makes in
- * `cli/src/engine.js` (`listClasses().filter((c) => HOST_CLASSES.includes(…))`):
- * the registry stays the single source of truth for every class that EXISTS,
- * and each host names the subset it offers. Removing this filter, or adding a
- * class here that `engine.listClasses()` does not return, is a one-line change
- * on this line — and the picker is built from this function's output, so a class
- * absent here is one no user can select, which is the whole point.
- */
-const DESKTOP_CLASSES = Object.freeze(['aegis', 'byok', 'local']);
-
-/**
- * Main -> renderer push channel for chat SSE deltas (D2.1 streaming render).
- * The invoke of aegis:chatCompletion still resolves once with the normalised
- * final result; live chunks travel on this single dedicated channel.
- */
-const CHAT_DELTA_CHANNEL = `${IPC_PREFIX}chatDelta`;
-
-/** Main -> renderer pushes for native menu accelerators (Cmd/Ctrl+N,
- *  Cmd/Ctrl+K) that have no Electron role to bind to — the renderer owns
- *  "new chat" and "open search" behaviour, so the menu just asks for it. */
-const MENU_NEW_CHAT_CHANNEL = `${IPC_PREFIX}menuNewChat`;
-const MENU_SEARCH_CHANNEL = `${IPC_PREFIX}menuSearch`;
-/** File > Save as… / Export session — same "menu has no state of its own,
- *  renderer does the work" pattern as the two channels above: the renderer
- *  knows the open session id, main.js just pings it. */
-const MENU_EXPORT_MARKDOWN_CHANNEL = `${IPC_PREFIX}menuExportMarkdown`;
-const MENU_EXPORT_JSON_CHANNEL = `${IPC_PREFIX}menuExportJson`;
-/** View > Authorship panel. The φ(α) card that used to open this sheet was
- *  removed from the sidebar (sealing runs in the background now), so the menu
- *  is what keeps the panel — key, records, vault — reachable at all. Same split
- *  as the channels above: main has no panel state, it just asks the renderer to
- *  open the sheet it already owns. */
-const MENU_FINGERPRINT_CHANNEL = `${IPC_PREFIX}menuFingerprint`;
-
-/**
- * Main -> renderer push for a resolved aegis:// deep link (D? deep linking).
- * Delivered once per link, after the target window has finished loading
- * (see sendDeepLinkToWindow) so the renderer's listener is always attached
- * before it arrives.
- */
-const DEEP_LINK_CHANNEL = `${IPC_PREFIX}deepLink`;
-
-/**
- * Main -> renderer push for a quick-launcher answer the user chose to keep
- * (D? quick launcher §4). Carries `{ prompt, response, model }`; the main
- * window's renderer already owns "add a turn to the open thread" (send()'s
- * addMessage + sync.append), so — same "menu pings, renderer acts" pattern as
- * MENU_NEW_CHAT_CHANNEL etc. — this just delivers the payload.
- */
-const QUICK_LAUNCHER_PUSH_CHANNEL = `${IPC_PREFIX}quickLauncherPush`;
-
-/**
- * Main -> renderer push for a queue drain's progress (one event per turn frame:
- * start/tool/delta/finish, plus recovered/queued/locked). Deliberately its OWN
- * channel rather than CHAT_DELTA_CHANNEL.
- *
- * A drain runs an unattended turn in a repository, and every one of its frames
- * is about that task — its tool calls, its output, its cost. Pushed onto the
- * chat delta channel they would be typed into whatever conversation the user
- * happens to have open (the preload's sessionId filter would have to be widened
- * to let them through at all), so the transcript would grow a second, unattached
- * answer nobody asked for. The queue is not a chat surface: the renderer shows
- * state and outcomes from this event, and the transcript stays clean.
- */
-const QUEUE_PROGRESS_CHANNEL = `${QUEUE_PREFIX}progress`;
-
-/**
- * How much task text the queue surface accepts, and how many rounds a queued
- * task may take. Both are ceilings on what ONE renderer call can ask the app to
- * spend: without them a pasted file would be queued as a task (every round
- * re-sends the prompt) and a task could pin the loop open indefinitely.
- * `workers` is capped at 8 to match the Model card's own input.
- */
-const QUEUE_MAX_TASK_CHARS = 8000;
-const QUEUE_MAX_ROUNDS = 200;
-const QUEUE_MAX_WORKERS = 8;
-
-/** The efforts the queue accepts; anything else means "let the worker decide"
- *  (autonomous.js resolveEffort, whose default is high for unattended work). */
-const QUEUE_EFFORTS = new Set(['low', 'medium', 'high']);
-
-/**
- * Address one SSE delta to the stream that produced it (D2.2 multi-stream).
- *
- * The renderer's chat flow runs a *set* of concurrent streams — the primary
- * answer plus the horizontal discovery lane — so every chunk must say which
- * sessionId it belongs to. `id` is added last so the routing tag stays
- * authoritative, while `delta` (and any future field the client sends) is
- * copied through untouched: existing single-stream callers that never set a
- * sessionId simply receive `id: undefined`, exactly the shape they see today.
- */
-function taggedChunk(chunk, sessionId) {
-  const base = chunk && typeof chunk === 'object' ? chunk : { delta: chunk };
-  return { ...base, id: sessionId };
-}
-
-const APP_VERSION = require('./package.json').version;
-
-/** Never ship a full key to the renderer — only a masked preview. */
-function maskKey(key) {
-  if (!key) return null;
-  if (key.length <= 10) return 'configured';
-  return `${key.slice(0, 9)}\u2026${key.slice(-4)}`;
-}
-
-/**
- * Classify a memory-endpoint failure: is this the plan's sync quota, or is it
- * just offline? aegis1 answers HTTP 402 `free_session_limit_reached` when a
- * WRITE would exceed the plan's synced-token ceiling (free = 1M, pro = 10M).
- * Since the quota became token-denominated, reads (search/pull) are always
- * served over quota, so only pushes can answer 402 — a pull that 402s is an
- * older server.
- *
- * The shared client attaches `err.status` / `err.data` (vendor/aegis.js
- * parseResponse) — but `ipcRenderer.invoke` only carries the *message string*
- * across the process boundary. A thrown cap therefore reaches the renderer as
- * the bare text "free_session_limit_reached" with `status`/`data` stripped,
- * which is why the upgrade UI in fetchMemory() never fired. So: detect it here,
- * in main, where the fields still exist, and hand the renderer a plain resolved
- * payload.
- *
- * Returns null for anything that is not a cap (offline, no key, 500, …).
- */
-function upgradeInfo(err) {
-  const status = err && err.status;
-  const data = (err && err.data) || {};
-  const code = typeof data.error === 'string' ? data.error : '';
-  if (status !== 402 && code !== 'free_session_limit_reached') return null;
-  // Quota numbers are TOKENS now (`tokensUsed` / `tokenLimit`). The legacy
-  // session-named keys are read only as a fallback so this build still shows a
-  // number against a server that predates the rename.
-  const used = data.tokensUsed != null
-    ? data.tokensUsed
-    : (data.sessionsUsed != null ? data.sessionsUsed : null);
-  const limit = data.tokenLimit != null
-    ? data.tokenLimit
-    : (data.freeSessionLimit != null ? data.freeSessionLimit : null);
-  return {
-    // Fallback only — aegis1 sends `upgradeUrl` on every 402. When it does not,
-    // point at the same `/go/upgrade` indirection the renderer uses (see
-    // renderer/app.js subscribeUrl()) rather than the bare /subscribe path, so
-    // the click is still attributed to the desktop channel + a campaign.
-    url: data.upgradeUrl || 'https://aegiscloud.org/go/upgrade?s=desktop&c=status_card',
-    used,
-    limit,
-    code: code || 'free_session_limit_reached',
-  };
-}
-
-/** Message text for a failure, without assuming the Error shape. */
-function errorText(err) {
-  return err && err.message ? err.message : String(err);
-}
-
-/**
- * Precise classification of a cloud-sync refusal — the desktop port of
- * `describeError()` in cli/src/cloudsync.js, so both hosts name a 402/401 the
- * same way instead of surfacing whatever sentence the server happened to use.
- *
- * `push()`/`pull()` used to hand the renderer `err.message` alone, so a
- * per-session memory-token 401 or a 402 reached the banner as
- * "sync failed: free_session_limit_reached" — a string that reads like a bug
- * and names no fix. The shared client attaches `err.status` / `err.data`
- * (vendor/aegis.js parseResponse) while the error is still in main, which is
- * why the classification happens here.
- *
- * `kind` is `quota` | `auth` | `error`; `hint` is the actionable half of the
- * sentence (what to do about it), null when there is nothing to say.
- */
-function describeSyncError(err) {
-  const status =
-    (err && (err.status || (err.response && err.response.status))) || 0;
-  const message = errorText(err);
-  // upgradeInfo() already knows the cap: either a 402 or the server's
-  // `free_session_limit_reached` code (an older body without a status).
-  if (upgradeInfo(err)) {
-    return {
-      kind: 'quota',
-      status: status || 402,
-      message,
-      hint:
-        "the plan's synced-token ceiling is reached — free space in the account dashboard or upgrade to keep syncing",
-    };
-  }
-  if (status === 401) {
-    return {
-      kind: 'auth',
-      status,
-      message,
-      hint: 'the memory token was refused — re-enter your AEGIS API key to exchange a new one',
-    };
-  }
-  return { kind: 'error', status: status || null, message, hint: null };
-}
-
-/** The banner line for a classified failure: the server's words + the fix. */
-function syncErrorReason(info) {
-  if (!info) return 'sync failed';
-  return info.hint ? `${info.message} — ${info.hint}` : info.message;
-}
-
-/**
- * Result shape for the two billing actions (`aegis:billingCheckout` and
- * `aegis:tokenBankTopup`). Both end in a Stripe-hosted checkout URL created
- * server-side, and both have failure modes the user has to be able to tell
- * apart: the free-plan cap (402), no/invalid API key (401), an amount the
- * server rejects (400), Stripe not configured on the server (503
- * `setup_required`), and a plain transport/500 error.
- *
- * The classification happens HERE for the same reason the memory paths
- * normalise: `ipcRenderer.invoke` carries only the message STRING across the
- * boundary, so `err.status` / `err.data` are gone by the time the renderer
- * sees a rejection. The renderer gets a resolved payload instead — never a
- * throw it would have to string-match.
- */
-async function billingResult(run) {
-  try {
-    const data = await run();
-    return {
-      ok: true,
-      url: (data && data.url) || null,
-      status: 0,
-      reason: null,
-      setupRequired: false,
-      upgrade: null,
-    };
-  } catch (err) {
-    const data = (err && err.data) || {};
-    return {
-      ok: false,
-      url: null,
-      status: (err && err.status) || 0,
-      reason: errorText(err),
-      setupRequired: Boolean(data.setup_required),
-      upgrade: upgradeInfo(err),
-    };
-  }
-}
-
-// The shared top-up core (client/topup.js) — the amount bounds, the balance
-// reading across aegis1's payload shapes, the unknown-not-zero rule and the
-// rising-read state machine. The TERMINAL drives the same file (`aegiscode
-// topup`), which is the reason it is shared rather than duplicated here: two
-// hosts reading a credit differently is how one surface shows money that the
-// other says never arrived.
-const {
-  // `bankAmount` is re-exported below for desktop/test/topup-credit-watch.test.mjs,
-  // which asserts the payload shapes through this host's surface.
-  bankAmount,
-  parseTopupAmount,
-  startTopup,
-  createCreditWatch,
-  TOPUP_POLL_MS,
-  TOPUP_POLL_TRIES,
-} = sharedTopup;
-
-let topupWatch = null;
-
-/**
- * Watch the account's token bank after a top-up checkout opens, and announce
- * the credit in-app when it lands.
- *
- * WHY THIS EXISTS. The top-up completes server-side — Stripe's webhook credits
- * the bank (services/billing_service.py) and the browser landing page is pure
- * UI on top of that — but that page (`/topup`) is `@login_required` against a
- * browser SESSION, and `POST /api/v1/auth/register-device` mints an account
- * whose password is never returned and whose email is `@device.aegiscloud`.
- * So the very account auto-provision creates cannot sign in to the page we
- * just sent it to: following that link lands on the login wall, and the user
- * is left believing the payment failed when the money and the credit are both
- * real.
- *
- * The key that STARTED the checkout is enough to READ the result: the same
- * `X-API-Key`/Bearer credential that creates the session also authenticates
- * `GET /api/token-bank/balance`. So the desktop confirms the credit itself.
- *
- * The STATE MACHINE is `createCreditWatch` in client/topup.js, driven by the
- * terminal host too — the same baseline, the same unknown-not-zero rule, the
- * same rising-read rule, one implementation. What this function adds is the
- * SCHEDULER and the notification, and both are host-specific: the timer lives
- * HERE and not in the renderer for the reason test/auto.test.mjs asserts
- * (timing belongs in the main process), and it means the notice still arrives
- * when the window is hidden — the normal case, since payment happens in the
- * user's browser.
- *
- * @param {object} aegis the client whose key created the checkout
- * @param {object} [opts]
- * @param {number} [opts.intervalMs] poll period (default TOPUP_POLL_MS)
- * @param {number} [opts.maxTries] attempts before giving up (default TOPUP_POLL_TRIES)
- * @param {function(number):void} [opts.notify] called once with the credited
- *   amount; defaults to an OS notification. Injectable so a test can observe
- *   the credit without a desktop runtime.
- * @param {function(string):void} [opts.log] optional warning sink
- */
-function watchTopupCredit(aegis, opts) {
-  const options = opts || {};
-  const intervalMs = options.intervalMs || TOPUP_POLL_MS;
-  const log = options.log;
-  if (topupWatch) clearInterval(topupWatch);
-  const watch = createCreditWatch(aegis, options.maxTries ? { maxTries: options.maxTries } : undefined);
-  const stop = () => {
-    if (topupWatch) clearInterval(topupWatch);
-    topupWatch = null;
-    watch.stop();
-  };
-  const announce = (amount) => {
-    if (typeof options.notify === 'function') {
-      options.notify(amount);
-      return;
-    }
-    try {
-      const Ctor = electron && electron.Notification;
-      if (Ctor && Ctor.isSupported()) {
-        new Ctor({
-          title: 'AEGIS Desktop',
-          body: `Bank credited — €${amount.toFixed(2)} available`,
-        }).show();
-      }
-    } catch {
-      /* a platform without notifications: the status card still shows it */
-    }
-  };
-  const tick = async () => {
-    const res = await watch.tick();
-    if (res.state === 'credited') {
-      stop();
-      announce(res.amount);
-    } else if (res.state === 'expired') {
-      stop();
-      if (log) log('top-up: no credit observed within the watch window; stopping');
-    }
-  };
-  topupWatch = setInterval(tick, intervalMs);
-  // Do not hold the event loop open for a payment that may never complete.
-  if (topupWatch && typeof topupWatch.unref === 'function') topupWatch.unref();
-  return { stop, tick, get baseline() { return watch.baseline; } };
-}
-
-/**
- * `aegis:memorySave` with the offline-first fallback (plan P3 §7): try the
- * cloud save first; if it fails (no key, offline, transient error) queue the
- * entry in <dir>/memory-queue.json instead of throwing, so the renderer's
- * "remember" affordance never surfaces an error for the no-key case. `dir` is
- * optional — callers that omit it (e.g. the desktop-shell smoke test) simply
- * get the un-queued rejection back, unchanged from before this existed.
- *
- * The cap is the one failure that is deliberately NOT queued: see upgradeInfo.
- * A 402 resolves `{ ok:false, upgrade }` — never thrown, because the fields
- * would not survive the IPC trip — and the entry is left un-stored so the
- * renderer can keep it in the box and point at the subscribe page.
- *
- * Level authority. This is the memory path's front door, so it is
- * the first of the award hooks. Two things happen before the write leaves:
- *
- *  1. The entry is *normalised* (store.js `normalizeMemoryEntry`). aegis1
- *     upserts on `(user_id, id)` and skips any entry without an `id`/`content`,
- *     so the renderer's bare `{ text, source }` was silently discarded
- *     server-side — paying XP for a save that never happened would be exactly
- *     the fake ledger this phase must not ship. A content-addressed id makes
- *     the save real and idempotent in one move.
- *  2. Only a save that LANDED pays: `memory.saved` (or `memory.reinforced` /
- *     `memory.corrected`, classified against the refs this process has seen —
- *     see store.js `observe`) after the cloud accepted it, and `memory.queued`
- *     for the offline path. A 402 pays nothing and queues nothing.
- *
- * `avatar` is optional: without it the function behaves exactly as before.
- */
-async function saveMemoryWithQueue(aegis, dir, entry, avatar) {
-  const normalized = avatarStore.normalizeMemoryEntry(entry);
-  try {
-    const result = await aegis.memorySave(normalized);
-    if (avatar && normalized && typeof normalized === 'object') {
-      avatar.awardSave(normalized, { session: normalized.session });
-    }
-    return result;
-  } catch (err) {
-    const upgrade = upgradeInfo(err);
-    if (upgrade) {
-      // Nothing was stored, so nothing is earned — and nothing is queued.
-      return { ok: false, queued: 0, saved: 0, upgrade, reason: errorText(err) };
-    }
-    if (!dir || !entry) throw err;
-    memoryQueue.enqueue(dir, normalized);
-    if (avatar && normalized && typeof normalized === 'object') {
-      avatar.awardQueued(normalized, { session: normalized.session });
-    }
-    return { ok: true, queued: true, reason: errorText(err) };
-  }
-}
-
-/**
- * Read side of the same normalisation. Since the sync quota became
- * token-denominated, aegis1 no longer refuses reads over quota — it serves
- * `memorySearch` / `memoryList` and reports `tokensUsed` / `tokenLimit` in the
- * payload. So an exhausted account arrives as a *success*, and the notice has
- * to be derived from the fields rather than from a thrown 402. The 402 branch
- * stays for an older server that still caps reads.
- *
- * Both paths resolve the same `upgrade` shape so the renderer keeps one branch.
- */
-async function normalizeMemoryRead(promise) {
-  try {
-    const data = await promise;
-    const quota = quotaFromPayload(data);
-    // Entries are deliberately preserved: an over-quota account still owns its
-    // memory and must see it. Only the notice is added.
-    return quota ? Object.assign({}, data, { upgrade: quota }) : data;
-  } catch (err) {
-    const upgrade = upgradeInfo(err);
-    if (!upgrade) throw err;
-    return { entries: [], upgrade };
-  }
-}
-
-/** Over-quota notice derived from a successful read payload, or null.
- *  `tokensUsed`/`tokenLimit` come from aegis1 `_token_quota_fields`. */
-function quotaFromPayload(data) {
-  if (!data || typeof data !== 'object') return null;
-  const used = data.tokensUsed != null ? data.tokensUsed : null;
-  const limit = data.tokenLimit != null ? data.tokenLimit : null;
-  if (used == null || limit == null || limit <= 0) return null;
-  if (used < limit) return null;
-  return {
-    // Same indirection as renderer/app.js subscribeUrl('memory_quota'): this is
-    // the sync-quota surface, and a bare /subscribe here would be an
-    // unattributable click.
-    url: 'https://aegiscloud.org/go/upgrade?s=desktop&c=memory_quota',
-    used,
-    limit,
-    code: 'sync_quota_reached',
-  };
-}
-
-/**
- * `aegis:memoryImport` — scan this machine for other AI tools' memory and,
- * when confirmed, push it into AEGIS cloud memory.
- *
- * Read-only against the foreign stores (client/foreign-memory.js never writes
- * to them). Two-phase by design: a dry run reports counts so the user can see
- * what would land before anything leaves the machine. When a confirmed save
- * can't reach the cloud (no key / offline), entries fall back to the same
- * local memory-queue the single-entry save path uses, so the import is not
- * lost — it flushes on the next "Sync now".
- *
- * The renderer gets counts and a summary string, never the entry bodies:
- * 1000 entries x 2 kB over IPC is pure waste, and the bodies are already
- * either in the cloud or in the queue by the time this resolves.
- *
- * Each batch that the cloud accepted pays `memory.imported` per
- * entry, keyed by the import's own source (foreign-memory.js collapses one
- * source's entries into ONE `import:<source>` session — aegis1 meters distinct
- * session values — so that value is the right per-source key). The replay caps
- * a source at 200 paying entries, and store.js caps the lines it writes to the
- * same number, so a ten-tool import cannot jump ten levels. Entries that fell
- * back to the local queue are queued events, not imports.
- */
-async function importForeignMemory(aegis, dir, payload, avatar) {
-  const opts = payload || {};
-  const report = foreignMemory.scan({
-    sources: opts.sources,
-    limit: opts.limit || 1000,
-  });
-  const summary = foreignMemory.describe(report);
-  const sources = report.sources.map((s) => ({
-    id: s.id,
-    label: s.label,
-    verified: s.verified,
-    present: s.present,
-    count: s.count,
-    skipped: s.skipped,
-    files: s.files,
-  }));
-
-  const base = { summary, totals: report.totals, sources };
-
-  if (!opts.confirm || !report.entries.length) {
-    return { ...base, ok: true, dryRun: !opts.confirm, saved: 0, queued: 0 };
-  }
-
-  let saved = 0;
-  let queued = 0;
-  const errors = [];
-  let upgrade = null;
-  for (const batch of foreignMemory.chunk(report.entries, 200)) {
-    try {
-      const data = await aegis.memorySaveBatch(batch);
-      saved += (data && data.saved) || batch.length;
-      if (avatar && batch.length) {
-        const first = batch[0] || {};
-        avatar.awardImports(batch, {
-          source: first.session || first.source || 'foreign-import',
-        });
-      }
-    } catch (err) {
-      // The cap is not an offline failure: don't queue the batch. The entries
-      // are still in the foreign stores, so a later scan re-finds them — but a
-      // queued copy would flush-fail forever and, worse, made a mid-import 402
-      // report as a silent `queued` count. Report the upgrade instead.
-      upgrade = upgradeInfo(err);
-      if (!upgrade && dir) {
-        // Offline-first, exactly like saveMemoryWithQueue(): keep the entries
-        // rather than dropping them. Anything already saved stays saved.
-        for (const entry of batch) {
-          memoryQueue.enqueue(dir, entry);
-          queued += 1;
-          if (avatar) avatar.awardQueued(entry, { session: entry && entry.session });
-        }
-      }
-      errors.push(errorText(err));
-      break;
-    }
-  }
-
-  return {
-    ...base,
-    ok: errors.length === 0,
-    dryRun: false,
-    saved,
-    queued,
-    upgrade,
-    reason: errors[0] || null,
-  };
-}
-
-/** Where the packaged/dev build keeps its icon files. Packaged: shipped via
- *  electron-builder.yml's `extraResources` into resourcesPath/icons/ (icons
- *  live outside asar, since app.icns/.ico aren't otherwise reachable at
- *  runtime). Dev: read straight from build/, the same source those resources
- *  are copied from. Same split as ae-guix's lib/windows.js. */
-function resolveIconsDir(isPackaged, resourcesPath, dirname) {
-  return isPackaged ? path.join(resourcesPath, 'icons') : path.join(dirname, 'build');
-}
-
-/** icon.icns on mac, icon.ico on Windows, icon.png everywhere else (Linux). */
-function iconForPlatform(iconsDir, platform) {
-  if (platform === 'darwin') return path.join(iconsDir, 'icon.icns');
-  if (platform === 'win32') return path.join(iconsDir, 'icon.ico');
-  return path.join(iconsDir, 'icon.png');
-}
-
-/** Only http/https may be opened externally — file://, javascript:, etc.
- *  would hand the OS shell an arbitrary URI straight from model output. */
-function isSafeExternalUrl(url) {
-  if (typeof url !== 'string' || !url) return false;
-  try {
-    const parsed = new URL(url);
-    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Whether this machine holds a provider route of the user's OWN — the "bring
- * your own key" half of the welcome block's two pitches.
- *
- * The AEGIS Cloud key is `aegis.apiKey` and is reported separately as
- * `keyConfigured`; a BYOK provider row never appears there (it is written by
- * the Provider settings card through settings.set(provider, {baseURL, key})),
- * so it needs its own reader. A row counts once it carries either a key (the
- * pasted-provider case) or a baseURL (the point-it-at-a-local-model case) —
- * both are the user having answered the question the block was asking.
- *
- * `settings.list()` goes through `get()`, which is the same reader the IPC
- * bridge uses to answer the renderer — it never puts the plaintext key on a
- * row (that would put it one `list()` call away from crossing IPC), only the
- * `configured` boolean it already derived from the key. Reading `row.key`
- * here was always reading a field `get()` doesn't emit, so a pasted-key-only
- * provider row (no baseURL — the common case: OpenAI, Anthropic, DeepSeek)
- * never counted and the block kept nagging a user who had already connected
- * one. Verified live: `store.set('openai', { key })` then `list()` — the row
- * carries `configured: true` and no `key` property at all.
- *
- * Reserved namespaces are excluded for the same reason createModelDispatch
- * filters them: they are the store's own bookkeeping (the AEGIS key, the
- * memory-persist preference), not a provider the user configured.
- *
- * Failure reads as "no", which keeps the block visible — the same
- * fail-toward-showing-it bias the CLI's connectNeeded() documents. Showing a
- * block the user has outgrown is a nag; hiding one a new install needed is a
- * dead end, and only the latter loses the user.
- */
-function providerRouteConfigured(engine) {
-  try {
-    const list = engine && engine.settings && engine.settings.list;
-    if (typeof list !== 'function') return false;
-    return (list.call(engine.settings) || []).some((row) => {
-      if (!row || !row.provider || isReservedNamespace(row.provider)) return false;
-      const baseURL = typeof row.baseURL === 'string' ? row.baseURL.trim() : '';
-      return Boolean(row.configured || baseURL);
-    });
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Pure mapping: IPC payload -> shared-client call. No Electron types here, so
- * tests can drive it with a stub client and a fake ipcMain. `openExternal` is
- * the one exception — it is itself just a function (default a harmless
- * reject), injected by bootstrap() so this module still needs no `electron`
- * import to stay unit-testable.
- */
-function createIpcDispatch(aegis, dir, persistApiKey, openExternal, providerConfigured, avatar, getVaultBackend) {
-  // One service for the window's lifetime, bound to the app's data dir — but
-  // created LAZILY, which is what the comment here always claimed and what the
-  // code did not do. `createFingerprintService({ dir })` throws on a missing
-  // dir, and a test or a call site that has no userData yet (every
-  // `createIpcDispatch(client)` in `test/desktop-shell.mjs`, and any bootstrap
-  // where `resolveUserDataDir` came back empty) died at construction — taking
-  // the whole dispatch surface with it, not just the fingerprint panel. The
-  // proxy defers construction to the first fingerprint call, so a broken shared
-  // module surfaces as an error in that panel instead of preventing the window
-  // from opening at all, exactly as documented below.
-  let fingerprintService = null;
-  const fingerprint = new Proxy({}, {
-    get(_target, prop) {
-      if (!fingerprintService) fingerprintService = createFingerprintService({ dir, getVaultBackend });
-      const value = fingerprintService[prop];
-      return typeof value === 'function' ? value.bind(fingerprintService) : value;
-    },
-    has(_target, prop) {
-      if (!fingerprintService) fingerprintService = createFingerprintService({ dir, getVaultBackend });
-      return prop in fingerprintService;
-    },
-  });
-  // `providerConfigured` is an injected thunk (bootstrap() passes one that reads
-  // the settings store) so this module keeps its no-Electron, unit-testable
-  // shape; absent in tests and older call sites, where it reads as "no".
-  const hasOwnProviderKey = () => {
-    try {
-      return Boolean(typeof providerConfigured === 'function' && providerConfigured());
-    } catch {
-      return false;
-    }
-  };
-  const openExternalFn = openExternal || (() => Promise.reject(new Error('no opener configured')));
-  const dispatch = {
-    status: () => ({
-      appVersion: APP_VERSION,
-      clientVersion: aegis.clientVersion,
-      apiBase: aegis.apiBase,
-      keyConfigured: Boolean(aegis.apiKey),
-      keyMask: maskKey(aegis.apiKey),
-      // The welcome block pitches TWO routes (bring your own key, or AEGIS
-      // Cloud) and must retire once the user has taken either one. A BYOK
-      // provider key never touches aegis.apiKey, so without this the block
-      // kept re-pitching "bring your own key" at someone who just did — see
-      // applyWelcomeConnect() in renderer/app.js.
-      providerConfigured: hasOwnProviderKey(),
-    }),
-
-    // In-app API key entry (plan rebuild): replace the live client key and
-    // persist it encrypted at rest via the settings store. The renderer only
-    // ever sees the masked preview back — never the raw key.
-    // Resolves `{ ok, ... }` / `{ ok: false, error }` rather than throwing —
-    // same reasoning as the fingerprint handlers below: an IPC rejection
-    // reaches the renderer as an opaque "Error invoking remote method" with
-    // the real cause buried in main-process logs, and key entry is the one
-    // flow every user hits on first run.
-    setApiKey: (payload) => {
-      try {
-        const key = payload && payload.key;
-        aegis.setApiKey(key || '');
-        if (persistApiKey) persistApiKey(aegis.apiKey);
-        return { ok: true, keyConfigured: Boolean(aegis.apiKey), keyMask: maskKey(aegis.apiKey) };
-      } catch (e) {
-        return { ok: false, error: (e && e.message) || String(e) };
-      }
-    },
-
-    verifyApiKey: async () => {
-      try {
-        return { ok: true, ...(await aegis.verifyApiKey()) };
-      } catch (e) {
-        return { ok: false, error: (e && e.message) || String(e) };
-      }
-    },
-    tokenBankBalance: () => aegis.tokenBankBalance(),
-
-    // Billing (plan upgrade + token-bank top-up). aegis1 creates a Stripe
-    // checkout session and answers `{ url }`; the renderer opens that URL
-    // through the same aegis:openExternal path the upgrade notices use, so a
-    // payment page is never rendered inside the app's own window. Both
-    // resolve a shaped result instead of rejecting — see billingResult().
-    billingCheckout: () => billingResult(() => aegis.billingCheckout()),
-    // A successful top-up opens Stripe in the user's browser, so the credit
-    // arrives long after this call returns. Start watching the bank now — the
-    // account key that created the session is the one credential that can read
-    // the result, and the auto-provisioned device key has no browser session to
-    // check it with. See watchTopupCredit().
-    //
-    // The AMOUNT and the failure classification come from the shared core
-    // (client/topup.js), the same one `aegiscode topup` drives: the renderer
-    // still receives this host's `{ ok, url, status, reason, setupRequired,
-    // upgrade }` shape (the renderer reads `reason`, not `message`), but the
-    // bounds and the "which status means what" decision are no longer written
-    // twice — a client that accepts 1 EUR is a round trip the user pays for
-    // with the server's rejection.
-    tokenBankTopup: async (payload) => {
-      const parsed = parseTopupAmount(payload && payload.amountEur);
-      if (!parsed.ok) {
-        return { ok: false, url: null, status: 400, reason: parsed.message, setupRequired: false, upgrade: null };
-      }
-      const res = await startTopup(aegis, parsed.amount);
-      if (res.ok === true && res.url) watchTopupCredit(aegis);
-      return {
-        ok: res.ok === true,
-        url: res.url,
-        status: res.status,
-        reason: res.ok ? null : (res.hint ? `${res.message} — ${res.hint}` : res.message),
-        setupRequired: res.setupRequired,
-        upgrade: null,
-      };
-    },
-
-    listModels: () => aegis.listModels(),
-
-    chatCompletion: (payload) =>
-      aegis.chatCompletion({
-        prompt: payload && payload.prompt,
-        system: payload && payload.system,
-        model: payload && payload.model,
-        mode: payload && payload.mode,
-        maxTokens: payload && payload.maxTokens,
-        // stream/onStream are forwarded when present; registerIpc() injects
-        // the IPC chunk forwarder for the desktop host (see below).
-        stream: payload && payload.stream,
-        onStream: payload && payload.onStream,
-      }),
-
-    // φ(α) — the authorship key and the sealed session records, the same ones
-    // `aegiscode fingerprint` mints in the terminal (lib/fingerprint.js).
-    // Every handler resolves `{ ok, … }` instead of rejecting, so the renderer
-    // can show the real message; an IPC rejection reaches it as an opaque
-    // "Error invoking remote method" with the reason buried in main-process
-    // logs, and the one error a user is likely to hit (a key file other users
-    // can read) is exactly the one that must be readable.
-    fingerprintStatus: () => fingerprint.status(),
-    fingerprintKeygen: (payload) => fingerprint.keygen(payload || {}),
-    fingerprintMint: (payload) => fingerprint.mint(payload || {}),
-    fingerprintVerify: (payload) => fingerprint.verify(payload || {}),
-    fingerprintBackup: (payload) => fingerprint.backup(payload || {}),
-    // The vault (client/record-vault.js). `publish` sends the SEALED BYTES to
-    // gdrive:AEGIS-AGPL/records and writes the `.anchor.json` link beside the
-    // local record; `anchor` checks the copy still matches; `vaultAudit`
-    // inspects the whole folder for key material. The key is never publishable —
-    // record-vault.js refuses it by path, by shape and by byte comparison, in
-    // the shared module rather than in this dispatch, so the CLI inherits the
-    // same refusal.
-    fingerprintPublish: (payload) => fingerprint.publish(payload || {}),
-    fingerprintAnchor: (payload) => fingerprint.anchor(payload || {}),
-    fingerprintVault: () => fingerprint.vaultList(),
-    fingerprintVaultAudit: () => fingerprint.vaultAudit(),
-    byokStatus: () => aegis.byokStatus(),
-    byokSet: (payload) =>
-      aegis.byokSet(
-        payload && payload.provider,
-        payload && payload.apiKey
-      ),
-
-    memorySearch: (payload) =>
-      normalizeMemoryRead(
-        aegis.memorySearch(payload && payload.query, payload && payload.limit)
-      ),
-    memorySave: (payload) =>
-      saveMemoryWithQueue(aegis, dir, payload && payload.entry, avatar),
-    memoryList: (payload) =>
-      normalizeMemoryRead(aegis.memoryList(payload && payload.limit)),
-
-    verifyToken: (payload) =>
-      aegis.verifyToken(payload && payload.token),
-    memoryActivate: (payload) =>
-      aegis.memoryActivate(payload && payload.token),
-    memoryPull: (payload) =>
-      aegis.memoryPull(payload && payload.since),
-    memorySaveBatch: (payload) =>
-      aegis.memorySaveBatch(payload && payload.entries),
-    memoryImport: (payload) =>
-      importForeignMemory(aegis, dir, payload, avatar),
-    importConversation: (payload) =>
-      aegis.importConversation(payload || {}),
-
-    // Links inside rendered markdown must never navigate the app's own
-    // BrowserWindow (that would point the chat UI at an arbitrary model-
-    // supplied origin) — they open in the OS default browser instead.
-    openExternal: (payload) => {
-      const url = payload && payload.url;
-      if (!isSafeExternalUrl(url)) {
-        return Promise.resolve({ ok: false, reason: 'unsupported URL scheme' });
-      }
-      return Promise.resolve(openExternalFn(url)).then(
-        () => ({ ok: true }),
-        (err) => ({ ok: false, reason: errorText(err) })
-      );
-    },
-  };
-  return dispatch;
-}
-
-/** Chain `onReplyFinished(event, result)` onto a dispatch promise without
- *  changing what it resolves/rejects with — the notifier is best-effort
- *  (native-notification side effect) and optional (undefined in every
- *  headless test path, where it is simply never called). */
-function withReplyNotify(promise, event, onReplyFinished) {
-  if (!onReplyFinished) return promise;
-  return promise.then((result) => {
-    onReplyFinished(event, result);
-    return result;
-  });
-}
-
-/** Register every dispatch method as `aegis:<name>` on ipcMain. `dir` (the
- *  user-data dir) is optional and threaded through only for the memorySave
- *  offline-queue fallback — see saveMemoryWithQueue(). `openExternal` is the
- *  real electron.shell.openExternal, injected by bootstrap(); omitted in
- *  tests, where the safe no-op default in createIpcDispatch takes over.
- *  `onReplyFinished` is likewise bootstrap()-only: it fires the native
- *  "reply ready" notification when the window is unfocused/hidden. */
-function registerIpc(ipcMain, aegis, dir, persistApiKey, openExternal, onReplyFinished, providerConfigured, getVaultBackend) {
-  const dispatch = createIpcDispatch(aegis, dir, persistApiKey, openExternal, providerConfigured, undefined, getVaultBackend);
-  for (const [name, handler] of Object.entries(dispatch)) {
-    if (name === 'chatCompletion') {
-      // Streaming render (D2.1): when the renderer asks for stream, SSE deltas
-      // are pushed over CHAT_DELTA_CHANNEL as they arrive while the invoke
-      // promise still resolves once with the normalised final result. When the
-      // payload does not request stream, behaviour is the plain non-streaming
-      // dispatch (what the headless shell test drives directly).
-      ipcMain.handle(`${IPC_PREFIX}${name}`, (event, payload) => {
-        const opts = { ...(payload || {}) };
-        if (!opts.stream) return withReplyNotify(handler(opts), event, onReplyFinished);
-        const sender = event && event.sender;
-        const forward = (chunk) => {
-          if (
-            sender &&
-            typeof sender.send === 'function' &&
-            !sender.isDestroyed()
-          ) {
-            // Address every delta with the request's sessionId (D2.2): the
-            // chat flow can run more than one stream at a time (the primary
-            // answer plus the horizontal discovery lane), so an unaddressed
-            // broadcast would interleave both replies into one bubble. The
-            // renderer's preload filters on `id`; chunks stay shape-compatible
-            // ({ delta }) for callers that never set a sessionId.
-            sender.send(CHAT_DELTA_CHANNEL, taggedChunk(chunk, opts.sessionId));
-          }
-        };
-        return withReplyNotify(
-          handler({ ...opts, stream: true, onStream: forward }),
-          event,
-          onReplyFinished
-        );
-      });
-      continue;
-    }
-    ipcMain.handle(`${IPC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/**
- * Tool-call approval toggle ("confirm mode"): `aegis:getConfirmMode` /
- * `aegis:setConfirmMode` (see registerConfirmModeIpc below). Pure injection of
- * the settings store, same shape as createQuickLauncherDispatch — so it is
- * unit-testable in plain Node with a stub store, and bootstrap() wires the
- * real one (desktop/lib/settings.js, reserved `__confirmMode` namespace).
- *
- * `{ enabled: true }` (the default) is the historical behaviour: the engine's
- * gate (desktop/lib/local/engine.js gatedExecuteTool) previews and asks before
- * every exec/writeFile/editFile. `false` lets the renderer's Settings switch
- * turn that off for good — the engine reads the flag per tool call, so the
- * change applies to the very next call, no restart.
- */
-function createConfirmModeDispatch(settings) {
-  if (!settings) throw new Error('createConfirmModeDispatch requires a settings store');
-  return {
-    getConfirmMode: () => ({ enabled: settings.getConfirmMode() }),
-    setConfirmMode: (payload) => {
-      // Absent/undefined means "off"? No — an explicit boolean is required to
-      // change anything: a malformed payload must not silently disable the
-      // approval gate, so it only ever sets what was clearly asked for.
-      const enabled = payload && payload.enabled;
-      if (typeof enabled !== 'boolean') return { enabled: settings.getConfirmMode() };
-      return { enabled: settings.setConfirmMode(enabled) };
-    },
-  };
-}
-
-/**
- * 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
- *  method there). */
-function registerConfirmModeIpc(ipcMain, dispatch) {
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${IPC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/**
- * Vault backend preference: `aegis:getVaultBackend` / `aegis:setVaultBackend`.
- * Same shape as createConfirmModeDispatch — unit-testable with a stub store —
- * and registered through the same generic registerConfirmModeIpc, which does
- * nothing confirm-mode-specific; it just wires `{name: handler}` pairs as
- * `aegis:<name>`.
- *
- * `getVaultBackend` answers `{ backend }`, one of
- * desktop/lib/settings.js's VAULT_BACKEND_VALUES ('aegiscloud' | 'drive' |
- * 'off'). `setVaultBackend` refuses an unrecognised value the same way
- * settings.setVaultBackendConfig does (returns the unchanged state rather than
- * writing something the fingerprint service's vaultScope()/vaultDisabled()
- * would not recognise either) — a bad payload cannot silently point the vault
- * somewhere, or at nothing, that the picker never actually offered.
- */
-function createVaultBackendDispatch(settings) {
-  if (!settings) throw new Error('createVaultBackendDispatch requires a settings store');
-  return {
-    getVaultBackend: () => settings.vaultBackendConfig(),
-    setVaultBackend: (payload) => settings.setVaultBackendConfig(payload && payload.backend),
-  };
-}
-
-/**
- * Funnel instrumentation (Phase 2 of docs/upgrade-conversion-plan.md):
- * `aegis:telemetryEvent` / `aegis:telemetryReport`, backed by the store in
- * lib/local/telemetry.js.
- *
- * Both handlers are FIRE-AND-FORGET by construction. `telemetryEvent` resolves
- * `{ ok }` and never rejects, never throws, and never does anything the caller
- * can observe: the renderer fires an event from the render path, so the worst
- * case here has to be a missing row, never a broken paint.
- *
- * The payload is rebuilt field by field (never spread) and the store re-checks
- * every field against its own allowlist. Two independent gates on purpose —
- * this is the boundary where "no API key, no conversation content, no paths,
- * no model output" has to hold, and one of them is allowed to be wrong.
- */
-function createTelemetryDispatch(telemetry) {
-  const store = telemetry || null;
-  return {
-    telemetryEvent: (payload) => {
-      try {
-        if (!store || typeof store.record !== 'function') return { ok: false, reason: 'telemetry off' };
-        const p = payload && typeof payload === 'object' ? payload : {};
-        const accepted = store.record(p.event, { campaign: p.campaign, surface: p.surface });
-        return accepted ? { ok: true } : { ok: false, reason: 'not an allowlisted funnel event' };
-      } catch (err) {
-        // A throw here would cross IPC as a rejected promise; the renderer must
-        // not be able to see telemetry fail at all.
-        return { ok: false, reason: errorText(err) };
-      }
-    },
-    // The summary path: what this install has buffered, per campaign. Read by
-    // the offline report script (scripts/funnel-report.mjs) for the baseline
-    // table; there is no server endpoint to ask yet.
-    telemetryReport: () => {
-      try {
-        if (!store || typeof store.report !== 'function') return { enabled: false, transport: 'off' };
-        return store.report();
-      } catch (err) {
-        return { enabled: false, error: errorText(err) };
-      }
-    },
-  };
-}
-
-/** Register telemetryEvent/telemetryReport as `aegis:<name>` — same
- *  ${IPC_PREFIX}<method> convention as registerConfirmModeIpc above. */
-/**
- * Pure mapping for the ÆGIS covenant's IPC surface — `aegis:covenantStatus`
- * and `aegis:covenantGapReport`.
- *
- * READ-ONLY BY CONSTRUCTION, and that is the whole point of the file: both
- * handlers return from `covenant.snapshot()` / `covenant.gapReport()`, which
- * are frozen descriptions of the sealed ÆL/1 stream. There is deliberately no
- * `setClause`, no `disable`, no `amend` and no `override` handler here — a
- * renderer cannot name what does not exist, so no IPC payload can edit,
- * waive or take the covenant out of circuit.
- *
- * §9 amendment invariant: ¬M(Λ1) ∧ ¬M(Λ2) ∧ ¬M(Λ4). Honesty, non-harm and
- * accountability are load-bearing and no vote, tier, config or message may
- * remove them — the desktop host included. Changing what is enforced means
- * re-sealing the artifact on disk, which is not reachable from a channel.
- *
- * `covenant` is injected rather than required directly so this is unit-
- * testable with a stub, same convention as createTelemetryDispatch /
- * createExportDispatch.
- */
-function createCovenantDispatch(covenant) {
-  return {
-    covenantStatus: () => {
-      const snapshot = covenant.snapshot();
-      return { ok: true, covenant: snapshot, gapReport: covenant.gapReport() };
-    },
-    covenantGapReport: () => ({ ok: true, gapReport: covenant.gapReport() }),
-  };
-}
-
-/** Register covenant dispatch methods as `aegis:<name>`, same convention as
- *  registerTelemetryIpc — read-only, see createCovenantDispatch. */
-function registerCovenantIpc(ipcMain, dispatch) {
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${IPC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-function registerTelemetryIpc(ipcMain, dispatch) {
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${IPC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/** Turn a session title/id into a filesystem-safe base filename. */
-function safeExportBasename(session) {
-  const base = (session && (session.title || session.id)) || 'session';
-  return base.replace(/[^\w.-]+/g, '_').slice(0, 80) || 'session';
-}
-
-/**
- * Pure mapping: `aegis:exportSession` -> read the session from the sessions
- * store (lib/sync/sessions.js is the single source of truth for its shape),
- * serialize it, then hand the (defaultPath, filters) to an injected
- * `showSaveDialog` and the resulting path + content to an injected
- * `writeFile`. Both are injected — exactly like `openExternal` on
- * createIpcDispatch — so this is unit-testable with stub functions and needs
- * no Electron import of its own; bootstrap() wires the real
- * dialog.showSaveDialog / fs.promises.writeFile.
- */
-function createExportDispatch(sessions, dir, showSaveDialog, writeFile) {
-  return {
-    exportSession: async (payload) => {
-      const sessionId = payload && payload.sessionId;
-      const format = payload && payload.format === 'json' ? 'json' : 'markdown';
-      const session = sessionId ? sessions.getSession(dir, sessionId) : null;
-      if (!session) return { ok: false, reason: 'session not found' };
-
-      const content = format === 'json' ? sessions.toJson(session) : sessions.toMarkdown(session);
-      const ext = format === 'json' ? 'json' : 'md';
-      const filters = format === 'json'
-        ? [{ name: 'JSON', extensions: ['json'] }]
-        : [{ name: 'Markdown', extensions: ['md'] }];
-
-      const dialogResult = await showSaveDialog({
-        defaultPath: `${safeExportBasename(session)}.${ext}`,
-        filters,
-      });
-      if (!dialogResult || dialogResult.canceled || !dialogResult.filePath) {
-        return { ok: false, canceled: true };
-      }
-
-      try {
-        await writeFile(dialogResult.filePath, content);
-      } catch (err) {
-        return { ok: false, reason: errorText(err) };
-      }
-      return { ok: true, filePath: dialogResult.filePath };
-    },
-  };
-}
-
-/** Register export dispatch methods as `aegis:<name>`, same convention as
- *  registerIpc()/registerUpdateIpc() above. */
-function registerExportIpc(ipcMain, sessions, dir, showSaveDialog, writeFile) {
-  const dispatch = createExportDispatch(sessions, dir, showSaveDialog, writeFile);
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${IPC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/**
- * Pure mapping: `quick:<name>` -> quick-launcher state. `opts.isPackaged`,
- * `opts.applyConfig` and `opts.pushToMain` are injected (default no-ops) so
- * this is unit-testable in plain Node, same pattern as createExportDispatch's
- * injected showSaveDialog/writeFile — bootstrap() wires the real
- * globalShortcut-backed applyConfig and window-relaying pushToMain.
- *
- * `applyConfig(cfg)` is expected to (re)register or unregister the global
- * shortcut for the given `{ enabled, shortcut }` and resolve/return
- * `{ active, reason }` — `reason` carries a human-readable cause the one time
- * registration fails (e.g. the accelerator is already claimed by another
- * app), so the renderer's settings card can show it instead of a silent
- * no-op. This module never throws on a failed registration; it degrades to
- * `active:false` and surfaces `reason`.
- */
-function createQuickLauncherDispatch(settings, opts = {}) {
-  const isPackaged = Boolean(opts.isPackaged);
-  const applyConfig = opts.applyConfig || (() => ({ active: false, reason: null }));
-  const pushToMain = opts.pushToMain || (() => ({ ok: false, reason: 'no main window' }));
-  let state = { active: false, reason: null };
-
-  function status() {
-    return { ...settings.quickLauncherConfig(), packaged: isPackaged, ...state };
-  }
-
-  function setConfig(payload) {
-    const saved = settings.setQuickLauncherConfig({
-      enabled: payload && payload.enabled,
-      shortcut: payload && payload.shortcut,
-    });
-    state = applyConfig(saved) || { active: false, reason: null };
-    return { ...saved, packaged: isPackaged, ...state };
-  }
-
-  return {
-    status,
-    setConfig,
-    pushToMain: (payload, event) => pushToMain(payload, event),
-  };
-}
-
-/** Register quick:<name> on ipcMain. `pushToMain` needs the raw IPC `event`
- *  (to hide the launcher window that sent it — see bootstrap()'s
- *  pushQuickLauncherResult), so it is special-cased exactly like
- *  aegis:chatCompletion is in registerIpc(); every other method drops the
- *  event, matching the rest of this file's convention. */
-function registerQuickLauncherIpc(ipcMain, dispatch) {
-  for (const [name, handler] of Object.entries(dispatch)) {
-    if (name === 'pushToMain') {
-      ipcMain.handle(`${QUICK_PREFIX}${name}`, (event, payload) => handler(payload, event));
-      continue;
-    }
-    ipcMain.handle(`${QUICK_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/**
- * Resolve the per-user data directory for settings + sessions. Electron gives
- * us app.getPath('userData'); outside Electron (headless smoke tests) fall back
- * to ~/.aegiscode so the pure functions can still be exercised.
- */
-function resolveUserDataDir(app) {
-  if (app && typeof app.getPath === 'function') {
-    try {
-      return app.getPath('userData');
-    } catch {
-      /* fall through */
-    }
-  }
-  return path.join(os.homedir(), '.aegiscode');
-}
-
-/**
- * Wire the real LocalEngine registry: the settings store + the shared cloud
- * client. Transport-only — no brain logic. Both shipping classes (aegis, byok)
- * reach their provider through that one client, so there is no second
- * transport to inject.
- */
-function createEngine(aegis, { app, safeStorage, dir: dirOverride, sessionsDir: sessionsOverride } = {}) {
-  // Settings (the safeStorage-encrypted key, window state, provider entries)
-  // stay in Electron's userData: they are this host's own, and the key is only
-  // readable by this process.
-  const settingsDir = dirOverride || resolveUserDataDir(app);
-  const settings = createSettingsStore({ dir: settingsDir, safeStorage });
-  // Relocate a pre-fix `settings['aegis']` key into the reserved namespace so
-  // it stops showing up as a provider. Ciphertext-level, so safe pre-'ready'.
-  settings.migrateLegacyAegisKey();
-  const engine = createLocalEngine({ aegis, settings });
-  // Sessions/memory live in the SHARED data dir ($AEGISCODE_HOME or
-  // ~/.aegiscode) — the same file the terminal host and the MCP plugin read —
-  // so a thread started in either shows up in the other without cloud sync and
-  // without a key. resolveStoreDir() also adopts a pre-unification
-  // userData/sessions.json, once, when the shared store is still empty, so an
-  // upgrade does not look like every conversation was deleted.
-  const sessionsDir = sessionsOverride || sessionStore.resolveStoreDir(settingsDir);
-  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).
- */
-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 = {
-    // The picker's source. Filtered through DESKTOP_CLASSES so this face never
-    // offers a class it cannot serve; see that constant for why `pro` is
-    // omitted here while the engine still ships it for the CLI.
-    listClasses: async () => (await engine.listClasses()).filter((c) => DESKTOP_CLASSES.includes(c.class)),
-    listModels: (payload) => engine.listModels(payload && payload.class),
-    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.
-    'settings.get': () =>
-      engine.settings.list().filter((s) => !(s && isReservedNamespace(s.provider))),
-    'settings.set': (payload) =>
-      engine.settings.set(payload && payload.provider, {
-        baseURL: payload && payload.baseURL,
-        key: payload && payload.key,
-      }),
-    '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),
-    // Ask the provider's OWN API which models its key reaches — the end of
-    // "type the vendor's model id from memory". The key stays in the main
-    // process: the renderer passes a provider id and gets back ids, never a
-    // credential, which is the same posture as the provider CRUD above.
-    //
-    // `userModels.addAll` is the bulk write the list makes possible (`/model-add
-    // <provider> '*'` in the CLI): a batch where one refused row does not abort
-    // the rest, and where the counts are returned so the row can say what
-    // actually happened.
-    'userModels.discover': (payload) => engine.discoverModels(payload && payload.provider),
-    'userModels.addAll': (payload) =>
-      engine.addUserModels(payload && payload.provider, payload && payload.ids),
-    'userModels.canDiscover': (payload) =>
-      Boolean(engine.canDiscoverModels(payload && payload.provider)),
-    'userModels.discoverable': () => engine.discoverableProviders(),
-    // 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
-    // request here; newChat() clears a conversation's "allow for this
-    // 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),
-  };
-
-  // 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;
-}
-
-/**
- * Pure mapping: sync:<name> -> sessions store call (unit-testable in Node).
- * `push`/`pull` are the P3 cloud-sync surface (plan §7/§8.5): they reuse the
- * shared client's memory-token auth (`aegis.conversationSyncPush/Pull`) — no
- * new credential flow. Offline-first: with no AEGIS key configured, both
- * resolve `{ ok: false, reason }` without ever throwing, and every local
- * flow (save/append/list) keeps working untouched.
- */
-function createSyncDispatch(sessions, dir, aegis, settingsDir) {
-  let lastSyncAt = null;
-
-  function hasCloud() {
-    return Boolean(aegis && aegis.apiKey);
-  }
-
-  /** Retry every locally queued memory-save (plan P3 §7 "queue locally and
-   *  sync later") now that the cloud is reachable. Entries that still fail
-   *  (e.g. one bad entry among several) stay queued for the next attempt. */
-  async function flushMemoryQueue() {
-    const queued = memoryQueue.listQueued(dir);
-    if (!queued.length) return { flushed: 0, remaining: 0, upgrade: null };
-    const remaining = [];
-    let flushed = 0;
-    let upgrade = null;
-    for (let i = 0; i < queued.length; i += 1) {
-      try {
-        await aegis.memorySave(queued[i]);
-        flushed += 1;
-      } catch (err) {
-        const capped = upgradeInfo(err);
-        if (capped) {
-          // A 402 is not "try again later": every remaining entry would fail
-          // the same way, the queue would never drain, and the paywall would
-          // stay invisible behind a "synced" toast. Stop, keep the rest
-          // queued for after the upgrade, and surface the cap to the renderer.
-          upgrade = capped;
-          remaining.push(...queued.slice(i));
-          break;
-        }
-        // Any other failure (offline / transient) keeps the entry queued.
-        remaining.push(queued[i]);
-      }
-    }
-    memoryQueue.save(dir, remaining);
-    return { flushed, remaining: remaining.length, upgrade };
-  }
-
-  async function push() {
-    const pending = sessions.listPending(dir);
-    if (!hasCloud()) {
-      return { ok: false, queued: pending.length, reason: 'no AEGIS key configured' };
-    }
-    const memoryFlush = await flushMemoryQueue();
-    if (!pending.length) {
-      return {
-        ok: true,
-        queued: 0,
-        pushed: 0,
-        memoryFlushed: memoryFlush.flushed,
-        upgrade: memoryFlush.upgrade,
-      };
-    }
-
-    let pushed = 0;
-    let lastError = null;
-    let lastInfo = null;
-    for (const session of pending) {
-      try {
-        const result = await aegis.conversationSyncPush({
-          session_id: session.id,
-          title: session.title,
-          messages: session.messages,
-        });
-        const remoteId = result && (result.session_id || result.id);
-        sessions.markSynced(dir, session.id, { remoteId });
-        pushed += 1;
-      } catch (err) {
-        lastError = err;
-        lastInfo = describeSyncError(err);
-        // A cap (402) or a refused memory token (401) fails identically for
-        // every later session — same reason the CLI stops there. One request
-        // per queued transcript against a refusal that cannot succeed is
-        // nothing but noise, so stop. The rest are left untouched (markSynced
-        // is never reached for them) and drain after the account is fixed.
-        if (lastInfo.kind === 'quota' || lastInfo.kind === 'auth') break;
-      }
-    }
-    const queued = sessions.listPending(dir).length;
-    if (pushed) lastSyncAt = Date.now();
-    // The session push is the path that hits the free-plan cap most often —
-    // every queued transcript re-bills the synced-token ceiling — so its
-    // upgrade metadata wins over the memory flush's. Without this, a capped
-    // session push answered `upgrade: null` and the renderer's capNotice()
-    // (the one place the paywall is visible) never fired.
-    const sessionUpgrade = lastError ? upgradeInfo(lastError) : null;
-    const upgrade = sessionUpgrade || memoryFlush.upgrade;
-    if (pushed === 0 && lastError) {
-      return {
-        ok: false,
-        queued,
-        reason: syncErrorReason(lastInfo),
-        // Additive: the renderer reads ok/queued/reason/upgrade exactly as
-        // before; these name the refusal without string-matching its wording.
-        failed: lastInfo ? [lastInfo] : [],
-        kind: lastInfo ? lastInfo.kind : 'error',
-        status: lastInfo ? lastInfo.status : 0,
-        hint: lastInfo ? lastInfo.hint : null,
-        memoryFlushed: memoryFlush.flushed,
-        upgrade,
-      };
-    }
-    return {
-      ok: true,
-      queued,
-      pushed,
-      // A partially failed push is still `ok` (the ones that went out are
-      // synced), but the reason is carried so nothing looks silently clean.
-      failed: lastInfo ? [lastInfo] : [],
-      memoryFlushed: memoryFlush.flushed,
-      upgrade,
-    };
-  }
-
-  async function pull() {
-    if (!hasCloud()) {
-      return { ok: false, merged: 0, reason: 'no AEGIS key configured' };
-    }
-    try {
-      const data = await aegis.conversationSyncPull();
-      const merged = sessions.mergeRemoteSessions(dir, (data && data.sessions) || []);
-      lastSyncAt = Date.now();
-      return { ok: true, merged, failed: [], upgrade: null };
-    } catch (err) {
-      const info = describeSyncError(err);
-      // Same shape as cli/src/cloudsync.js pull(): a classified `failed[]`
-      // instead of a bare message to string-match, plus the cap metadata when
-      // this was a 402 — the renderer's syncNow() reads `pullResult.upgrade`
-      // alongside the push's, so a pull that hits the cap now lights the
-      // upgrade banner too.
-      return {
-        ok: false,
-        merged: 0,
-        reason: syncErrorReason(info),
-        failed: [info],
-        kind: info.kind,
-        status: info.status,
-        hint: info.hint,
-        upgrade: upgradeInfo(err),
-      };
-    }
-  }
-
-  // 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 || {}),
-    append: (payload) =>
-      sessions.appendMessage(
-        dir,
-        payload && payload.sessionId,
-        payload && payload.message
-      ),
-    delete: (payload) =>
-      sessions.deleteSession(dir, payload && payload.sessionId),
-    push,
-    pull,
-    status: () => ({
-      count: sessions.listSessions(dir).length,
-      pending: sessions.listPending(dir).length,
-      cloud: hasCloud(),
-      lastSyncAt,
-    }),
-  };
-}
-
-/** First retry delay and the ceiling for the heartbeat push backoff. */
-const HEARTBEAT_RETRY_BASE_MS = 5000;
-const HEARTBEAT_RETRY_MAX_MS = 30000;
-
-/**
- * Backoff for the fire-and-forget heartbeat push (plan §7 "retry on a
- * heartbeat"). `model:listModels` and `sync:status` each fire one, and the
- * renderer polls both — so a permanently failing push (offline, refused
- * memory token, free-plan cap) used to burn a request on every single one,
- * forever, with `.catch(() => {})` swallowing the reason.
- *
- * Now: exponential backoff from `baseMs` to `maxMs`, reset on success, and the
- * last error is retained (`state()`) so a stuck sync is visible on the
- * sync:status payload instead of disappearing into an empty catch.
- *
- * `push` is expected to resolve a `{ ok:false, reason }` result rather than
- * throw (that is createSyncDispatch's contract) — both are counted, because
- * only counting throws would leave the offline case retrying every heartbeat.
- * `now`/`baseMs`/`maxMs` are injectable so the tests can drive the ladder
- * without sleeping.
- */
-function createHeartbeatRetry(push, opts = {}) {
-  const now = typeof opts.now === 'function' ? opts.now : () => Date.now();
-  const baseMs = Number(opts.baseMs) > 0 ? Number(opts.baseMs) : HEARTBEAT_RETRY_BASE_MS;
-  const maxMs = Number(opts.maxMs) > 0 ? Number(opts.maxMs) : HEARTBEAT_RETRY_MAX_MS;
-  let failures = 0;
-  let nextAttemptAt = 0;
-  let lastError = null;
-  let inFlight = false;
-
-  /** 5s, 10s, 20s, 30s, 30s… — capped, never unbounded. */
-  const delayFor = () => Math.min(maxMs, baseMs * 2 ** Math.max(0, failures - 1));
-
-  function fail(reason) {
-    failures += 1;
-    const wait = delayFor();
-    lastError = reason || 'push failed';
-    nextAttemptAt = now() + wait;
-    return { attempted: true, ok: false, error: lastError, failures, retryInMs: wait };
-  }
-
-  async function run() {
-    const t = now();
-    if (failures > 0 && t < nextAttemptAt) {
-      // Backing off: no request, no state change — the caller keeps whatever
-      // reason is already on record.
-      return { attempted: false, ok: false, error: lastError, failures, retryInMs: nextAttemptAt - t };
-    }
-    if (inFlight) {
-      return { attempted: false, ok: false, error: lastError, failures, retryInMs: 0 };
-    }
-    inFlight = true;
-    try {
-      const result = await push();
-      if (result && result.ok === false) {
-        return fail(result.reason || result.kind || 'push failed');
-      }
-      // Success resets the ladder: the next heartbeat goes straight out.
-      failures = 0;
-      nextAttemptAt = 0;
-      lastError = null;
-      return { attempted: true, ok: true, error: null, failures: 0, retryInMs: 0, result };
-    } catch (err) {
-      return fail(errorText(err));
-    } finally {
-      inFlight = false;
-    }
-  }
-
-  /** Snapshot for the renderer: what failed and how long until the retry. */
-  function state() {
-    const t = now();
-    return {
-      failures,
-      lastError,
-      retryInMs: failures > 0 && nextAttemptAt > t ? nextAttemptAt - t : 0,
-    };
-  }
-
-  return { run, state, recordFailure: (err) => fail(errorText(err)) };
-}
-
-/**
- * Register model:<name> and sync:<name> on ipcMain. `model:chat` is always
- * streaming: deltas are pushed over CHAT_DELTA_CHANNEL exactly like the
- * existing `aegis:chatCompletion` special case. `aegis` (the shared client)
- * is optional — headless/offline callers omit it and every sync method falls
- * back to its no-cloud branch.
- *
- * `model:listModels` and `sync:status` also fire a background retry push of
- * any pending sessions (plan §7 "retry on a heartbeat"): fire-and-forget,
- * never awaited, never throws — it just gives queued sessions another
- * chance to sync without a dedicated poller. The retry is rate-limited by
- * createHeartbeatRetry (exponential backoff, reset on success); its last error
- * rides along on the sync:status result so the renderer can show it.
- *
- * `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. `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, settingsDir) {
-  const modelDispatch = createModelDispatch(engine);
-  const syncDispatch = createSyncDispatch(sessionStore, sessionsDir, aegis, settingsDir);
-
-  const heartbeat = createHeartbeatRetry(() => syncDispatch.push(), heartbeatOpts);
-
-  function heartbeatRetry() {
-    // run() classifies its own failures, so this catch is a last-resort guard
-    // (never an empty swallow): the reason is recorded for the banner either way.
-    const attempt = heartbeat.run();
-    if (attempt && typeof attempt.catch === 'function') {
-      attempt.catch((err) => heartbeat.recordFailure(err));
-    }
-  }
-
-  for (const [name, handler] of Object.entries(modelDispatch)) {
-    if (name === 'chat') {
-      ipcMain.handle(`${MODEL_PREFIX}${name}`, (event, payload) => {
-        const opts = { ...(payload || {}) };
-        // The rung every renderer sends is low|medium|high; this is the one
-        // place a stale window can still hand us the retired `auto` (a page
-        // loaded before the select lost that row, or a renderer that forgot to
-        // resolve), and a falsy effort is NOT "the engine's default" — the
-        // shared engine states the field conditionally, so an absent value
-        // means "state no opinion" and the server sizes the turn itself. So it
-        // is normalised here rather than passed through: an unknown value
-        // becomes `high`, the same floor the engine and the CLI apply, and no
-        // turn can reach the wire with an effort nobody chose.
-        const effortRung =
-          opts.effort === 'low' || opts.effort === 'medium' ? opts.effort : 'high';
-        opts.effort = effortRung;
-        const sender = event && event.sender;
-        const forward = (chunk) => {
-          if (
-            sender &&
-            typeof sender.send === 'function' &&
-            !sender.isDestroyed()
-          ) {
-            // Two streams can be live at once (main answer + discovery lane),
-            // so each delta carries the sessionId it belongs to. See the
-            // matching note on the aegis:chatCompletion forwarder.
-            sender.send(CHAT_DELTA_CHANNEL, taggedChunk(chunk, opts.sessionId));
-          }
-        };
-        return withReplyNotify(
-          handler({ ...opts, onStream: forward }),
-          event,
-          onReplyFinished
-        );
-      });
-      continue;
-    }
-    if (name === 'listModels') {
-      ipcMain.handle(`${MODEL_PREFIX}${name}`, (_event, payload) => {
-        heartbeatRetry();
-        return handler(payload);
-      });
-      continue;
-    }
-    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) => {
-        heartbeatRetry();
-        const result = handler(payload);
-        // Additive: `retry` carries the last heartbeat failure and the wait
-        // until the next attempt, so a stuck sync is visible instead of
-        // swallowed. The local status fields are untouched.
-        return result && typeof result === 'object'
-          ? { ...result, retry: heartbeat.state() }
-          : result;
-      });
-      continue;
-    }
-    ipcMain.handle(`${SYNC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-
-  return { modelDispatch, syncDispatch, heartbeat };
-}
-
-// ─────────────────────────── the local autonomous work queue ───────────────
-//
-// `desktop/lib/local/queue.js` (the durable queue) and
-// `desktop/lib/local/autonomous.js` (the worker that drives the engine's tool
-// loop) shipped with no host using them. This is the desktop host's half: a
-// `queue:` IPC surface, a settings-independent engine for the worker, and the
-// one rule that makes the whole thing safe to leave in a GUI — NOTHING DRAINS
-// UNLESS THE USER ASKED. There is no interval, no drain at startup, and no
-// drain-on-idle anywhere in this file. Draining is spend (a full tool loop on a
-// real model, in the user's checkout); a queue that starts itself when the
-// window is left alone is a feature nobody consented to, so the only callers of
-// `drain`/`proceed` are the two buttons on the renderer's queue card.
-
-/**
- * A local engine for the queue worker: the same tool loop the interactive chat
- * runs, with the tool-approval gate hard OFF.
- *
- * The gate exists to ask a human before exec/writeFile/editFile. A queued task
- * is unattended BY DEFINITION — there is nobody to click — and engine.js's
- * requestApproval() resolves only on a click or on an abort, so a gated engine
- * here would mean a worker parked on an approval card forever (a `running`
- * queue item, a held lock, and no record of why). Gate off is the honest
- * configuration: the worker runs the tools it was asked to run, and the
- * renderer's card says so in as many words.
- */
-function createQueueEngine(aegis, settings) {
-  return createLocalEngine({
-    aegis,
-    settings,
-    getConfirmMode: () => false,
-  });
-}
-
-/**
- * The second net under createQueueEngine's gate-off engine.
- *
- * If an approval request still reaches a drain — a caller that wired the
- * interactive engine by mistake, or a future engine change — answer it here
- * rather than leave a card nobody can click. The answer is always 'deny': a
- * queued task may decide to run the tools it was configured to run, but it may
- * never silently grant a permission the user reserves for a click. Denying lets
- * the turn continue to its own conclusion, where autonomous.js — which watches
- * the same `{ approval }` frame — settles the task as failed with the reason
- * written down. A hang would have recorded nothing at all.
- */
-function queueEngineWithDeniedApprovals(engine) {
-  if (!engine || typeof engine.chat !== 'function') return engine;
-  const deny = (chunk) => {
-    const approval = chunk && chunk.approval;
-    if (!approval || !approval.id) return;
-    if (typeof engine.respondApproval !== 'function') return;
-    try {
-      engine.respondApproval(approval.id, 'deny');
-    } catch {
-      /* 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);
-      });
-    },
-  };
-}
-
-/** True when `p` is an existing directory (the only path check this surface
- *  makes: a task's cwd is where its tool loop runs, so a typo there has to be
- *  refused now rather than fail minutes later inside a turn's output). */
-function isExistingDir(p) {
-  try {
-    return fs.statSync(p).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-/** An integer within [min,max], or null for "not stated". */
-function clampInt(value, min, max) {
-  const n = Number(value);
-  if (!Number.isInteger(n) || n < min || n > max) return null;
-  return n;
-}
-
-/**
- * Pure mapping: `queue:<name>` -> queue.js + autonomous.js. Unit-testable in
- * plain Node with a stub engine and a temp AEGIS_QUEUE_FILE, exactly like
- * createIpcDispatch/createExportDispatch above — `engine` is injected (the
- * real one comes from createQueueEngine in bootstrap()), and every path the
- * queue touches comes from `env`.
- *
- * The methods are thin: `enqueue`/`retry`/`remove`/`clear` are the queue file's
- * own vocabulary, and `drain`/`proceed` are one and many `worker.proceed({max:
- * 1})` ticks. The worker itself owns the lock, the digest, the round horizon
- * and the settle-back-into-the-file write; none of that is re-implemented here.
- *
- * `stop` is the renderer's Stop button. It has to be its own method rather than
- * "cancel the current turn": cancelling a turn leaves the next pending task to
- * start immediately, which is not what a user who just pressed Stop asked for.
- */
-function createQueueDispatch({
-  engine,
-  env = process.env,
-  queue = queueModule,
-  autonomous = autonomousModule,
-  // Phase 4 of docs/upgrade-conversion-plan.md: the Pro boundary for the queue.
-  // Injected so a test can hand in a stub verdict, and defaulted to a REAL
-  // gate that probes nothing (an unresolved gate is the free boundary) rather
-  // than to "no gate at all" — a caller that forgets to pass one must not get
-  // the free fan-out.
-  entitlement = entitlementModule.createEntitlement({}),
-  log = () => {},
-} = {}) {
-  if (!engine || typeof engine.chat !== 'function') {
-    throw new Error('createQueueDispatch: a local engine with chat() is required');
-  }
-
-  // The task the current drain is working, learned from the worker's own
-  // start/finish frames, so `stop` can cancel the turn actually in flight.
-  let running = null;
-  // Set by `stop`, read between ticks by drainAll. Reset when a drain starts.
-  let stopRequested = false;
-  // This window's drain. queue.js's file lock is what stops a SECOND process;
-  // this flag stops a second click in the same window from queueing up a second
-  // loop (which would only be refused by the lock after a round trip).
-  let draining = false;
-
-  const emit = (event) => {
-    if (event && event.type === 'start') running = event.taskId;
-    if (event && event.type === 'finish') running = null;
-    log(event);
-  };
-
-  const worker = autonomous.createQueueWorker({
-    engine: queueEngineWithDeniedApprovals(engine),
-    env,
-    log: emit,
-    // The drain-time half of the gate: a task that asks for the fan-out but
-    // belongs to a session that is not entitled to it runs as a SINGLE PASS
-    // (autonomous.js says so out loud over a `note` frame). This is what closes
-    // the path the enqueue check cannot see — a `singlePass: false` task queued
-    // by the CLI or written into queue.jsonl by hand, which is already in the
-    // file before main.js is asked anything. Read fresh per task from the cached
-    // verdict, so a purchase mid-drain upgrades the very next task.
-    canFanOut: () => entitlement.current().entitled,
-  });
-
-  /** What the renderer paints from: the queue file, the run log, and whether
-   *  this window is currently draining. Read fresh on every call — the queue is
-   *  a file several hosts write to, so a cached copy would show a stale list. */
-  function snapshot() {
-    const items = queue.loadQueue(env);
-    return {
-      ok: true,
-      items,
-      pending: queue.pendingCount(items),
-      running: items.find((i) => i && i.status === 'running') || null,
-      draining,
-      stopping: stopRequested,
-      defaultCwd: process.cwd(),
-      // What a task with no model of its own, on the Aegis Cloud class, actually
-      // runs on — a pooled tier id. byok and local tasks always carry an
-      // explicit model (see autonomous.js modelRefusal), so there is no
-      // equivalent default to report for those classes. The card prints this
-      // 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 }),
-      // What this session may spend on (Phase 4). The renderer paints the
-      // boundary from THIS and decides nothing itself: the fan-out control, the
-      // #queue-hint line and the refusal link are all state it was told.
-      entitlement: entitlement.current(),
-    };
-  }
-
-  /**
-   * Coerce one renderer payload into queue.addTask's opts.
-   *
-   * There is no shell field on this surface and no path the main process reads
-   * or writes on the renderer's behalf: `cwd` is the directory the task's own
-   * tool loop runs in, it must be absolute and already exist, and it is passed
-   * through unmodified. model/effort/workers/maxRounds are ids, rungs and small
-   * integers — never commands — and every one of them is range-checked here so
-   * a malformed payload is refused with a reason instead of queued as work that
-   * silently runs with defaults.
-   */
-  function taskOpts(payload) {
-    const p = payload || {};
-    const task = String(p.task == null ? '' : p.task).trim();
-    if (!task) return { error: 'a queued task needs text' };
-    if (task.length > QUEUE_MAX_TASK_CHARS) {
-      return { error: `task text is too long (${task.length} > ${QUEUE_MAX_TASK_CHARS} chars)` };
-    }
-    const cwd = String(p.cwd == null ? '' : p.cwd).trim() || process.cwd();
-    if (!path.isAbsolute(cwd)) return { error: 'the working directory must be an absolute path' };
-    if (!isExistingDir(cwd)) return { error: `not a directory: ${cwd}` };
-
-    const cls = autonomous.normalizeClass(p.class);
-    const model = String(p.model == null ? '' : p.model).trim().slice(0, 120) || null;
-    // Refused HERE so the card gets the reason at the moment of queueing
-    // instead of a red row later. queue.addTask enforces the same (model,
-    // class) rule for the CLI and for hand-written queue files — see
-    // autonomous.js modelRefusal for what each class requires.
-    const modelRefusal = autonomous.modelRefusal(model, cls);
-    if (modelRefusal) return { error: modelRefusal };
-    const effortRaw = String(p.effort == null ? '' : p.effort).trim().toLowerCase();
-    return {
-      opts: {
-        task,
-        cwd,
-        class: cls,
-        model,
-        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. Fan-out is an Aegis Cloud mechanism only — a
-        // byok/local task that somehow carried `fanout: true` is NOT honoured
-        // as a fan-out here (autonomous.js's runTask forces it off for any
-        // non-aegis class regardless of this flag), but it is still recorded
-        // as the task's own ask rather than silently rewritten, matching
-        // resolveFanout's "a wrong pick is reported, not rewritten" rule.
-        singlePass: !(p.fanout === true || p.autonomous === true),
-        commit: Boolean(p.commit),
-        source: 'desktop',
-      },
-    };
-  }
-
-  /** `settle`-shaped one-liner per finished task, so the drain's answer carries
-   *  the outcome of every task it ran rather than only the last one. */
-  const summarize = (ran) =>
-    (ran || []).map((r) => ({ id: r.id, ok: Boolean(r.ok), error: r.error || null }));
-
-  // Note on `commit`: neither drain accepts a commit override from the
-  // renderer. Whether a task commits is a property of the TASK (the checkbox it
-  // was queued with, carried in the queue file), so `worker.proceed` is called
-  // with the flag undefined and autonomous.js falls back to each item's own
-  // `commit`. A drain-level flag would let one click rewrite another task's
-  // decision.
-
-  async function drainOnce() {
-    if (draining) return { ok: false, reason: 'a drain is already running in this window', ...snapshot() };
-    draining = true;
-    stopRequested = false;
-    let result;
-    try {
-      const tick = await worker.proceed({ max: 1 });
-      result = tick.locked
-        ? { ok: false, locked: true, holder: tick.holder, ran: [] }
-        : { ok: true, ran: summarize(tick.ran) };
-    } catch (err) {
-      // A drain that throws must still leave a readable answer (and a queue
-      // that can be inspected), not a rejected IPC promise the renderer would
-      // paint as "Invoke failed".
-      result = { ok: false, reason: errorText(err), ran: [] };
-    }
-    draining = false;
-    running = null;
-    return { ...result, ...snapshot() };
-  }
-
-  async function drainAll() {
-    if (draining) return { ok: false, reason: 'a drain is already running in this window', ...snapshot() };
-    draining = true;
-    stopRequested = false;
-    const ran = [];
-    let result;
-    try {
-      for (;;) {
-        // One task per tick through the worker's own proceed: it re-reads the
-        // FILE each time (so a task added mid-drain is picked up) and takes and
-        // releases the lock around each task, which is what lets Stop land
-        // between two tasks instead of after the whole queue.
-        const tick = await worker.proceed({ max: 1 });
-        if (tick.locked) {
-          result = { ok: false, locked: true, holder: tick.holder, ran: summarize(ran) };
-          break;
-        }
-        if (!tick.ran.length) {
-          result = { ok: true, stopped: stopRequested, ran: summarize(ran) };
-          break;
-        }
-        ran.push(...tick.ran);
-        if (stopRequested) {
-          result = { ok: true, stopped: true, ran: summarize(ran) };
-          break;
-        }
-      }
-    } catch (err) {
-      result = { ok: false, reason: errorText(err), ran: summarize(ran) };
-    }
-    draining = false;
-    running = null;
-    return { ...result, ...snapshot() };
-  }
-
-  return {
-    /** Queue one task. */
-    enqueue: async (payload) => {
-      // Re-probe first (a no-op while the cached verdict is fresh), so a user
-      // who bought Pro and came straight back is not refused with a verdict
-      // from before they paid.
-      await entitlement.refresh();
-      // THE GATE. It runs here, in main, on the renderer's own numbers — a
-      // renderer that never renders the fan-out control (or one driven from the
-      // devtools console) is refused here just the same, because nothing in the
-      // renderer is trusted to enforce anything.
-      const gate = entitlement.gateFanout({
-        workers: clampInt(payload && payload.workers, 1, QUEUE_MAX_WORKERS),
-        fanout: Boolean(payload && payload.fanout === true),
-      });
-      if (!gate.ok) return { ...gate, ...snapshot() };
-      const { opts, error } = taskOpts(payload);
-      if (error) return { ok: false, reason: error, ...snapshot() };
-      const item = queue.addTask(env, opts);
-      return { ok: true, item, ...snapshot() };
-    },
-
-    /** Current state: the list, what is running, what is pending, recent runs. */
-    list: () => snapshot(),
-
-    /** What this session is entitled to (Phase 4). `force: true` re-probes
-     *  instead of answering from the cache — the card's "check again" path, and
-     *  what the renderer calls on boot so the boundary line is never a guess. */
-    entitlement: async (payload) => {
-      await entitlement.refresh({ force: Boolean(payload && payload.force === true) });
-      return { ok: true, ...snapshot() };
-    },
-
-    /** Drop finished tasks (or everything with `all`). Pending and running tasks
-     *  are kept — queue.clearQueue's rule, not this surface's. */
-    clear: (payload) => ({
-      ...queue.clearQueue(env, { all: Boolean(payload && payload.all) }),
-      ok: true,
-      ...snapshot(),
-    }),
-
-    /** Put a finished/failed task back in line, keeping its attempt count. */
-    retry: (payload) => {
-      const id = payload && payload.id;
-      const item = queue.retryTask(env, id);
-      if (!item) return { ok: false, reason: `no task #${id}`, ...snapshot() };
-      return { ok: true, item, ...snapshot() };
-    },
-
-    /** Remove one task by id. A running task is refused: the worker holds it in
-     *  memory and writes its outcome back, so deleting it mid-turn would just be
-     *  re-created by that settle — stop it first. */
-    remove: (payload) => {
-      const id = payload && payload.id;
-      const items = queue.loadQueue(env);
-      const item = queue.findTask(items, id);
-      if (!item) return { ok: false, reason: `no task #${id}`, ...snapshot() };
-      if (item.status === 'running') {
-        return { ok: false, reason: `task #${item.id} is running — stop the drain first`, ...snapshot() };
-      }
-      queue.saveQueue(env, items.filter((i) => Number(i && i.id) !== Number(item.id)));
-      return { ok: true, removed: item.id, ...snapshot() };
-    },
-
-    /** Work exactly one pending task (the card's "Run one"). */
-    drain: () => drainOnce(),
-
-    /** Work pending tasks until the queue is empty, or Stop is pressed. */
-    proceed: () => drainAll(),
-
-    /** Stop: cancel the turn in flight AND the loop, so the next pending task
-     *  does not simply start. */
-    stop: (payload) => {
-      stopRequested = true;
-      const id = payload && payload.id != null ? payload.id : running;
-      const cancel = id == null ? null : worker.cancel(id);
-      return { ok: true, wasDraining: draining, cancelled: cancel, ...snapshot() };
-    },
-  };
-}
-
-/**
- * The two opt-in automations, as an IPC surface (`auto:<name>`).
- *
- * lib/auto.js owns the TIMING; this owns the ANSWERS the renderer gets, and
- * deliberately nothing else: it has no timer of its own, it does not read the
- * settings store (the automations do, on every tick), and it does not touch the
- * queue file or a record (the queue worker and lib/fingerprint.js do). Split
- * out as a pure function so a test can drive it with stub automations and a
- * fake ipcMain, exactly like createQueueDispatch.
- *
- * `sealNow` is the panel's explicit "seal this session" shortcut through the
- * AUTOMATION rather than through the fingerprint service directly, so the
- * pending-turn counter is reset by the same call that files the record — a
- * manual seal followed by the timer must not file the same session twice.
- */
-function createAutoDispatch({ autoDrain, autoMint } = {}) {
-  if (!autoDrain || typeof autoDrain.state !== 'function') {
-    throw new Error('createAutoDispatch: the auto-drain automation is required');
-  }
-  if (!autoMint || typeof autoMint.state !== 'function') {
-    throw new Error('createAutoDispatch: the auto-mint automation is required');
-  }
-  return {
-    /** Both switches and both live states, in one answer. */
-    autoStatus: () => ({ ok: true, drain: autoDrain.state(), mint: autoMint.state() }),
-    autoSetDrain: (payload) => {
-      const p = payload || {};
-      const patch = {};
-      if (p.enabled != null) patch.enabled = Boolean(p.enabled);
-      if (p.intervalMs != null) patch.intervalMs = Number(p.intervalMs);
-      try {
-        return { ok: true, drain: autoDrain.set(patch) };
-      } catch (err) {
-        return { ok: false, error: errorText(err) };
-      }
-    },
-    autoSetMint: (payload) => {
-      const p = payload || {};
-      const patch = {};
-      if (p.enabled != null) patch.enabled = Boolean(p.enabled);
-      if (p.publish != null) patch.publish = Boolean(p.publish);
-      try {
-        return { ok: true, mint: autoMint.set(patch) };
-      } catch (err) {
-        return { ok: false, error: errorText(err) };
-      }
-    },
-    /** Seal the open session now, ahead of the quiet timer. Resets the counter
-     *  either way: a seal that failed is still not something to retry from a
-     *  timer that was about to fire on the same turns, and the panel shows the
-     *  failure. */
-    autoSealNow: async (payload) => {
-      const p = payload || {};
-      if (p.publish != null) autoMint.set({ publish: Boolean(p.publish) });
-      try {
-        const result = await autoMint.flush();
-        autoMint.reset();
-        return { ok: true, ...result };
-      } catch (err) {
-        autoMint.reset();
-        return { ok: false, error: errorText(err) };
-      }
-    },
-  };
-}
-
-/**
- * Register the queue surface as `queue:<name>` on ipcMain — the same
- * per-namespace pattern as MODEL_PREFIX/SYNC_PREFIX/QUICK_PREFIX above, with
- * one addition: every handler keeps the raw IPC event, because a drain's
- * progress frames are pushed to the window that ASKED for it, over
- * QUEUE_PROGRESS_CHANNEL (never CHAT_DELTA_CHANNEL — see that constant).
- *
- * Every handler, not just drain/proceed: with the auto-drain switch armed the
- * drain is started by a TIMER, so there is no "window that asked for it" — the
- * sink has to be whichever window last touched this surface (the card that
- * armed the switch, or the one that just read queue.list()). Leaving only
- * drain/proceed to set `target` would make an automatic drain's progress
- * invisible in exactly that case, and an invisible drain reads as a hang.
- */
-function registerQueueIpc(ipcMain, { engine, env, queue, autonomous, entitlement, aegis } = {}) {
-  // The window a drain's frames go to. One drain runs at a time process-wide
-  // (queue.js's lock), so a single target is enough, and a second window's
-  // drain is refused by the lock rather than interleaving two progress streams.
-  let target = null;
-  // Pro boundary (Phase 4). The signal is the account's own plan, read from the
-  // endpoint the app already calls to verify a key — aegis1 `/api/verify-api-key`
-  // answers `{ valid, plan, … }` (its docstring says so), and `plan` is the
-  // column aegis1's billing_service normalizes its PAID_PLANS against. Read-only,
-  // one small POST per TTL, nothing written server-side, no new billing system.
-  //
-  // What this does NOT cover, stated here so it cannot be forgotten: the CLI's
-  // own drain (`aegiscode autonomous`) is a different host with no session to
-  // ask, so the fan-out ceiling is enforced for the DESKTOP queue only.
-  const resolved = entitlement || entitlementModule.createEntitlement({
-    // Phase 6: entitlement is TWO readings, not one. `/api/verify-api-key`
-    // answers the plan; `/api/token-bank/balance` answers the prepaid bank, and
-    // the bank is the operator's lever — aegis1 app.py: "Pool-key users with
-    // token bank balance skip legacy credit checks." Either one clears the
-    // wall. A failed balance call leaves the balance UNKNOWN rather than
-    // inventing a zero, so a network blip cannot manufacture a paywall prompt;
-    // classifyProbe then fails closed on the unknown.
-    probe: aegis && typeof aegis.verifyApiKey === 'function'
-      ? async () => {
-        const verify = await aegis.verifyApiKey();
-        const body = verify && typeof verify === 'object' ? { ...verify } : {};
-        if (typeof aegis.tokenBankBalance === 'function') {
-          try {
-            const bank = await aegis.tokenBankBalance();
-            if (bank && typeof bank === 'object') {
-              if (bank.balance_micros != null) body.balance_micros = bank.balance_micros;
-              else if (bank.balance_eur != null) body.balance_eur = bank.balance_eur;
-            }
-          } catch {
-            // Unknown stays unknown. No grant, no wall invented from a blip.
-          }
-        }
-        return body;
-      }
-      : undefined,
-  });
-  const dispatch = createQueueDispatch({
-    engine,
-    env,
-    queue,
-    autonomous,
-    entitlement: resolved,
-    log: (event) => {
-      if (!target || typeof target.send !== 'function') return;
-      if (typeof target.isDestroyed === 'function' && target.isDestroyed()) return;
-      target.send(QUEUE_PROGRESS_CHANNEL, event);
-    },
-  });
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${QUEUE_PREFIX}${name}`, (event, payload) => {
-      target = (event && event.sender) || null;
-      return handler(payload);
-    });
-  }
-  return dispatch;
-}
-
-/**
- * Register the automation surface as `auto:<name>` on ipcMain.
- *
- * Unlike the queue, no handler here needs the IPC event: these calls are
- * answers about a switch, not a stream, and the one long-running one
- * (`sealNow`) resolves its own result. Nothing is pushed to the renderer from
- * this file — the card and the panel re-read status after every action, which
- * is also what makes a stale paint impossible.
- */
-function registerAutoIpc(ipcMain, dispatch) {
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${AUTO_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/**
- * Main -> renderer push channel for auto-update status (mirrors
- * CHAT_DELTA_CHANNEL): the renderer's update banner listens here instead of
- * polling `aegis:updateStatus`.
- */
-const UPDATE_STATUS_CHANNEL = `${IPC_PREFIX}updateStatus`;
-const ACCOUNT_STATUS_CHANNEL = `${IPC_PREFIX}accountStatusChanged`;
-
-/** Re-check for a new release every few hours — frequent enough that a
- *  long-lived session still notices a release, rare enough to not hammer
- *  the GitHub Releases API. */
-const UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000;
-
-/**
- * Auto-update state machine over electron-updater (GitHub Releases provider,
- * configured via desktop/electron-builder.yml `publish:` — see main.js's
- * top-of-file note and that file's comment for the feed this points at).
- *
- * Deliberately inert outside a packaged app: `electron .` in dev has no
- * app-update.yml (electron-builder only writes one at build time), so
- * calling checkForUpdates() there would just throw on every launch. Rather
- * than special-case that error, `isPackaged: false` skips wiring the real
- * autoUpdater entirely and every method resolves a harmless 'disabled'
- * state — dev never touches the network or the update machinery.
- *
- * `autoDownload` stays false: checking happens automatically (on ready and
- * on the interval below), but the multi-hundred-MB download itself only
- * starts when the renderer's banner "Download" button calls download() —
- * see the IPC dispatch below. This keeps every step user-visible and
- * matches the "never auto-restart without consent" rule: quitAndInstall()
- * is likewise only ever invoked by an explicit "Restart to install" click.
- */
-
-/**
- * Update state backed by the npm registry, for installs that are not packaged
- * electron builds (i.e. `npm i -g aegis-desktop`).
- *
- * Mirrors the electron-updater manager's shape exactly so the IPC dispatch and
- * the renderer banner need no branch: status/check/download/quitAndInstall/
- * start. `download` and `quitAndInstall` are no-ops that report the install
- * command instead of acting — npm owns installation here, and silently
- * swapping the package under a running process is not something to do on the
- * user's behalf.
- */
-/**
- * How long to wait before re-checking after a FAILED background check: 1m, 5m,
- * 15m, then hourly.
- *
- * The 4h interval is right for a successful check — the answer changes slowly —
- * and wrong for a failure, whose usual cause (no network yet at login, a VPN
- * still coming up, a one-off registry blip) is gone inside a minute. Before
- * this, a machine that launched before its Wi-Fi associated showed a hard error
- * for the next four hours.
- */
-const UPDATE_RETRY_BACKOFF_MS = [60_000, 5 * 60_000, 15 * 60_000, 60 * 60_000];
-
-/**
- * The sentence the banner shows. Every one of these used to be the single fixed
- * string "registry unreachable" — including a 404 and a 2.5s timeout, neither of
- * which is evidence the registry was unreachable. Only the last two are claims
- * about the network, and only when the socket actually failed.
- */
-function describeRegistryFailure(reason, status, pkg) {
-  switch (reason) {
-    case 'not-found':
-      return `${pkg} is not published on the npm registry (404)`;
-    case 'forbidden':
-      return `the npm registry refused the request (${status || 'auth'})`;
-    case 'malformed':
-      return 'the npm registry sent a response this app could not read';
-    case 'too-large':
-      return 'the npm registry response was too large to read';
-    case 'timeout':
-      return 'the npm registry did not respond in time';
-    case 'network':
-      return 'the npm registry could not be reached';
-    default:
-      return 'the update check did not complete';
-  }
-}
-
-function createNpmUpdateManager({
-  onStatus,
-  now = () => Date.now(),
-  fetchImpl,
-  setTimeoutImpl = setTimeout,
-  clearTimeoutImpl = clearTimeout,
-  // Both injectable so the install path is testable without running npm or
-  // killing the test runner's own process.
-  runUpgrade,
-  relaunch,
-} = {}) {
-  const PKG = 'aegis-desktop';
-  let current = 'unknown';
-  try {
-    current = require('./package.json').version;
-  } catch {
-    /* version is cosmetic here */
-  }
-  // `reason`/`transient`/`attempts`/`retryInMs`/`canDownload` are additive: the
-  // banner needs them to decide whether a failure deserves the user's
-  // attention at all, and whether there is a button worth offering.
-  let state = {
-    status: 'idle',
-    version: null,
-    error: null,
-    channel: 'npm',
-    reason: null,
-    transient: false,
-    attempts: 0,
-    retryInMs: 0,
-    command: null,
-    // `plan` is the shared verdict the banner was rendered from. `download()`
-    // installs from THIS object rather than re-deriving a command, so the
-    // button can only ever run what the banner promised.
-    plan: null,
-    method: null,
-    canDownload: false,
-  };
-  const set = (patch) => {
-    state = { ...state, ...patch };
-    if (onStatus) onStatus(state);
-    return state;
-  };
-
-  // Same repo-then-vendor idiom every other shared module here uses.
-  let updater = null;
-  try {
-    updater = require('../client/update.js');
-  } catch {
-    try {
-      updater = require('./vendor/update.js');
-    } catch {
-      updater = null;
-    }
-  }
-
-  let attempts = 0;
-  let retryAt = 0;
-  let retryTimer = null;
-  let inFlight = null;
-  let interval = null;
-
-  /**
-   * How THIS desktop copy was installed: 'npm' | 'pip' | 'npx' | 'source'.
-   *
-   * Memoised — it cannot change while the process runs. `entry` is the app
-   * directory: an unpackaged run is either a global npm install (a path with
-   * `node_modules` in it), a checkout (`desktop/` beside `.git`), or a pip
-   * launcher, which declares itself through AEGIS_INSTALL_METHOD because
-   * nothing in the filesystem would otherwise say so.
-   */
-  let methodCache = null;
-  function detectMethod() {
-    if (methodCache) return methodCache;
-    const detect = updater && updater.detectInstallMethod;
-    if (typeof detect !== 'function') { methodCache = 'npm'; return methodCache; }
-    try {
-      methodCache = detect({
-        env: process.env,
-        argv: process.argv,
-        pkg: PKG,
-        entry: __dirname,
-        fileExists: (rel) => fs.existsSync(path.resolve(__dirname, '..', rel)),
-      });
-    } catch {
-      methodCache = 'npm';
-    }
-    return methodCache;
-  }
-
-  /** 1m, 5m, 15m, 60m, 60m… — capped, never unbounded. */
-  const delayFor = () =>
-    UPDATE_RETRY_BACKOFF_MS[Math.min(Math.max(attempts - 1, 0), UPDATE_RETRY_BACKOFF_MS.length - 1)];
-
-  function clearRetry() {
-    if (retryTimer) clearTimeoutImpl(retryTimer);
-    retryTimer = null;
-  }
-
-  /** One silent re-check after a transient failure, instead of a 4h wait. */
-  function scheduleRetry() {
-    clearRetry();
-    const delay = delayFor();
-    retryAt = now() + delay;
-    retryTimer = setTimeoutImpl(() => {
-      retryTimer = null;
-      check().catch(() => {});
-    }, delay);
-    if (retryTimer && retryTimer.unref) retryTimer.unref();
-    set({ retryInMs: delay });
-  }
-
-  /**
-   * Always a detailed result — and, since AEGISONE (D7), always from the ONE
-   * shared check.
-   *
-   * This function used to ask the registry itself (`fetchLatestDetailed`, with
-   * a `fetchLatest` fallback), which made the desktop a second place that knew
-   * how to fetch a published version: a second timeout, a second failure
-   * taxonomy, and a banner that could disagree with `aegiscode`'s. It now
-   * consumes `client/update.js::checkPublished` — the same probe, the same
-   * 2.5s timeout and the same `REASONS` as the CLI's notice and `aegis doctor`.
-   *
-   * `intervalMs: 0` is deliberate: the *schedule* stays this manager's (it
-   * polls every `UPDATE_CHECK_INTERVAL_MS` and drives its retry ladder off the
-   * result), but the *check* is not re-implemented here. The desktop keeps its
-   * applier — `electron-updater` below — and loses its own version fetch.
-   */
-  async function fetchDetailed() {
-    if (fetchImpl) return fetchImpl({ pkg: PKG });
-    if (updater && typeof updater.checkPublished === 'function') {
-      const res = await updater.checkPublished({ current, pkg: PKG, now: now(), intervalMs: 0 });
-      return res
-        ? { ok: res.ok, latest: res.latest, reason: res.reason, status: res.status }
-        : { ok: false, latest: null, reason: 'unknown', status: null };
-    }
-    // The shared checker is present but predates `checkPublished`. The vendored
-    // copy ships in the same bundle as this file, so this is a repackaging
-    // accident rather than a supported older release — and the honest answer is
-    // "the checker is unavailable", not a private fetching path that would
-    // reintroduce the second check D7 exists to delete.
-    return { ok: false, latest: null, reason: 'unavailable', status: null };
-  }
-
-  const isTransient = (reason, status) => {
-    if (typeof updater.isTransientReason === 'function') return updater.isTransientReason(reason, status);
-    return reason === 'unknown'; // unclassified: assume retryable, stay quiet
-  };
-
-  /**
-   * `announce: false` (the default) is the background check: a network failure
-   * is swallowed and re-tried on the backoff ladder. `announce: true` is a
-   * check the user explicitly asked for (the app menu, the banner's Retry
-   * button) — they are looking at the answer, so they get it.
-   *
-   * Coalesced: the interval, the menu, the Retry button and the renderer's
-   * initial status poll can all land together, and three registry hits for one
-   * question is pointless.
-   */
-  async function check({ announce = false } = {}) {
-    if (!updater) return set({ status: 'disabled', error: 'update checker unavailable' });
-    if (inFlight) return inFlight;
-
-    inFlight = (async () => {
-      // What we already knew, so a transient failure cannot erase it.
-      const priorStatus = state.status;
-      const priorVersion = state.version;
-      set({ status: 'checking', error: null, reason: null, transient: false });
-
-      let res;
-      try {
-        res = await fetchDetailed();
-      } catch (err) {
-        res = { ok: false, latest: null, reason: 'unknown', status: null, error: errorText(err) };
-      }
-
-      if (res.ok) {
-        attempts = 0;
-        retryAt = 0;
-        clearRetry();
-        if (!updater.isNewer(res.latest, current)) {
-          return set({
-            status: 'up-to-date', version: res.latest, error: null, reason: null,
-            transient: false, attempts: 0, retryInMs: 0,
-          });
-        }
-        // The npm applier's instruction comes from the ONE shared verdict
-        // (`updatePlan`), the same call `aegiscode`'s notice and `aegis doctor`
-        // render — so the banner cannot offer a command the terminal would not.
-        //
-        // `method` is this copy's install channel, detected the same way the
-        // CLI does. It matters because `npm i -g` against a pip-installed
-        // aegis-desktop writes a second copy beside the one the user actually
-        // runs: the button would appear to work and change nothing.
-        const method = detectMethod();
-        const plan = typeof updater.updatePlan === 'function'
-          ? updater.updatePlan({ current, latest: res.latest, behind: true, channel: 'npm', pkg: PKG, method })
-          : null;
-        return set({
-          status: 'available',
-          version: res.latest,
-          error: null,
-          reason: null,
-          transient: false,
-          attempts: 0,
-          retryInMs: 0,
-          plan,
-          method,
-          command: (plan && plan.instruction) || `npm i -g ${PKG}@latest`,
-          // A channel with an `apply` argv has something this process can run;
-          // `npx` and a source checkout do not, and offering a button that
-          // silently does nothing is worse than the command alone.
-          canDownload: Boolean(plan && plan.apply),
-        });
-      }
-
-      attempts += 1;
-      const message = res.error || describeRegistryFailure(res.reason, res.status, PKG);
-
-      if (isTransient(res.reason, res.status)) {
-        scheduleRetry();
-        if (!announce) {
-          // Nobody asked. The network was not there yet; that is not news, and
-          // an 'available' verdict we already earned must survive it.
-          return set({
-            status: priorStatus === 'available' ? 'available' : 'unavailable',
-            version: priorVersion,
-            error: message,
-            reason: res.reason,
-            transient: true,
-            attempts,
-          });
-        }
-        return set({ status: 'error', error: message, reason: res.reason, transient: true, attempts });
-      }
-
-      // The registry answered and the answer was no (404, 403, unreadable). That
-      // is a real condition, it will not fix itself in a minute, and only the
-      // user can act on it — so it is shown either way, named accurately.
-      clearRetry();
-      retryAt = 0;
-      return set({
-        status: 'error', error: message, reason: res.reason,
-        transient: false, attempts, retryInMs: 0,
-      });
-    })();
-
-    try {
-      return await inFlight;
-    } finally {
-      inFlight = null;
-    }
-  }
-
-  /**
-   * Run one installer argv and resolve to a status patch. Never rejects.
-   *
-   * `npm i -g` against a global prefix needs no elevation the way a system
-   * package does, but it still writes outside the app dir and it can fail on a
-   * permissions wall — so a failure is reported with npm's own last lines
-   * rather than a blanket "update failed".
-   */
-  function runInstall(target) {
-    const exec = runUpgrade || ((cmd, args) => new Promise((resolve) => {
-      execFile(cmd, args, { timeout: 180_000, windowsHide: true }, (err, stdout, stderr) => {
-        if (err) return resolve({ ok: false, output: String(stderr || stdout || err.message || err) });
-        resolve({ ok: true, output: String(stdout || '') });
-      });
-    }));
-    return Promise.resolve(exec(target.command, target.args)).then(
-      (res) => ({ ok: Boolean(res && res.ok), output: String((res && res.output) || '') }),
-      (err) => ({ ok: false, output: errorText(err) }),
-    );
-  }
-
-  return {
-    status: () => state,
-    check,
-    /**
-     * The banner's Download button. It INSTALLS.
-     *
-     * This used to be a no-op that re-set `command` and `canDownload:false`:
-     * the button was hidden for every npm install, so the affordance and the
-     * action were both missing, and the only way to update the window was to
-     * read a shell command off a banner and type it into a different app.
-     *
-     * It still runs only on an explicit click (nothing here installs on a
-     * timer), and it still does not hot-swap the running process: after a
-     * successful install the honest state is 'downloaded' — "restart to install"
-     * — because the new files are on disk and this process is still the old
-     * ones. That is the same promise the packaged electron-updater path makes,
-     * so the banner needs no branch.
-     */
-    download: async () => {
-      const target = state.plan && state.plan.apply;
-      if (!target) {
-        // Nothing to install on this channel (npx fetches fresh every run; a
-        // checkout belongs to its git remote). Say who owns it instead of
-        // pretending to act.
-        return set({
-          status: state.status === 'available' ? 'available' : state.status,
-          command: (state.plan && state.plan.instruction) || state.command,
-          canDownload: false,
-        });
-      }
-      set({ status: 'downloading', error: null, progress: 0 });
-      const res = await runInstall(target);
-      if (!res.ok) {
-        // `transient: false` deliberately: an installer that refused is not a
-        // network blip, and the retry ladder must not quietly re-run an npm
-        // install every minute.
-        return set({
-          status: 'error',
-          transient: false,
-          error: res.output.trim().split('\n').slice(-3).join(' ').trim() || 'the installer failed',
-          command: `${target.command} ${target.args.join(' ')}`,
-        });
-      }
-      return set({
-        status: 'downloaded',
-        version: state.version,
-        error: null,
-        progress: 100,
-        command: `npm i -g ${PKG}@latest`,
-        canDownload: false,
-      });
-    },
-    /**
-     * "Restart to install". Relaunches the app so the freshly installed files
-     * are what runs — `app.relaunch()` before `app.exit()`, the standard pair,
-     * because `app.quit()` alone would not start a new process.
-     */
-    quitAndInstall: () => {
-      if (state.status !== 'downloaded') return;
-      const again = relaunch || (() => {
-        try {
-          const { app } = require('electron');
-          app.relaunch();
-          app.exit(0);
-        } catch {
-          /* not under Electron (a test or the CLI): nothing to relaunch */
-        }
-      });
-      again();
-    },
-    start: () => {
-      check().catch(() => {});
-      interval = setInterval(() => check().catch(() => {}), UPDATE_CHECK_INTERVAL_MS);
-      if (interval.unref) interval.unref();
-    },
-    // Timers are the reason this exists: a retry timer outliving the window
-    // would keep a dead check alive past app quit.
-    stop: () => {
-      clearRetry();
-      if (interval) clearInterval(interval);
-      interval = null;
-    },
-    retryState: () => ({ attempts, retryAt, inFlight: !!inFlight, hasTimer: !!retryTimer }),
-  };
-}
-
-function createUpdateManager({ autoUpdater, isPackaged, onStatus }) {
-  let state = { status: 'idle', version: null, error: null, canDownload: false };
-
-  function setState(patch) {
-    state = { ...state, ...patch };
-    if (onStatus) onStatus(state);
-  }
-
-  if (!isPackaged || !autoUpdater) {
-    // Not a packaged build — which is how this app is INSTALLED FROM NPM, not
-    // just how it runs in dev. That case used to resolve a flat 'disabled' and
-    // never check anything, so an npm-installed desktop could never learn a
-    // new version existed.
-    //
-    // electron-updater's configured feed is GitHub Releases
-    // (electron-builder.yml `publish:`), and there has never been a published
-    // release to read — the only one is a draft, invisible to the updater, and
-    // the release workflow cannot run while Actions is billing-locked. So the
-    // feed the packaged path depends on does not exist, while the registry we
-    // actually publish to does.
-    //
-    // npm is therefore the real update channel. Checking it costs one request
-    // a day, reports the version and the exact command, and deliberately does
-    // NOT self-install: replacing your own running process mid-session is a
-    // different promise from telling you an update exists.
-    return createNpmUpdateManager({ onStatus: setState });
-  }
-
-  autoUpdater.autoDownload = false;
-  autoUpdater.autoInstallOnAppQuit = false;
-
-  autoUpdater.on('checking-for-update', () => setState({ status: 'checking', error: null }));
-  autoUpdater.on('update-available', (info) =>
-    setState({ status: 'available', version: info && info.version, error: null, canDownload: true })
-  );
-  autoUpdater.on('update-not-available', () => setState({ status: 'up-to-date', error: null }));
-  autoUpdater.on('download-progress', (progress) =>
-    setState({ status: 'downloading', progress: progress && progress.percent })
-  );
-  autoUpdater.on('update-downloaded', (info) =>
-    setState({ status: 'downloaded', version: info && info.version, error: null })
-  );
-  // Any failure — offline, a malformed feed, a 404 on latest.yml — lands
-  // here instead of an unhandled rejection, since electron-updater emits
-  // 'error' for background failures that occur outside the promise a
-  // check()/download() call is awaiting.
-  autoUpdater.on('error', (err) => setState({ status: 'error', error: errorText(err) }));
-
-  async function check() {
-    try {
-      await autoUpdater.checkForUpdates();
-    } catch (err) {
-      setState({ status: 'error', error: errorText(err) });
-    }
-    return state;
-  }
-
-  async function download() {
-    try {
-      await autoUpdater.downloadUpdate();
-    } catch (err) {
-      setState({ status: 'error', error: errorText(err) });
-    }
-    return state;
-  }
-
-  function quitAndInstall() {
-    autoUpdater.quitAndInstall();
-  }
-
-  function start() {
-    check();
-    const timer = setInterval(check, UPDATE_CHECK_INTERVAL_MS);
-    // Never keep the process alive solely to poll for updates.
-    if (timer.unref) timer.unref();
-  }
-
-  return { status: () => state, check, download, quitAndInstall, start };
-}
-
-/** Pure mapping: IPC payload -> update-manager call, same shape as
- *  createIpcDispatch — unit-testable with a stub updateManager. */
-function createUpdateDispatch(updateManager) {
-  return {
-    // The renderer only ever calls this from an explicit click (the banner's
-    // Retry), so it is announced: a user who asks gets a truthful answer about
-    // a failure instead of the silence the background check prefers.
-    checkForUpdates: () => updateManager.check({ announce: true }),
-    downloadUpdate: () => updateManager.download(),
-    quitAndInstallUpdate: () => {
-      updateManager.quitAndInstall();
-      return { ok: true };
-    },
-    updateStatus: () => Promise.resolve(updateManager.status()),
-  };
-}
-
-/** Register update dispatch methods as `aegis:<name>`, same convention as
- *  registerIpc() above. */
-function registerUpdateIpc(ipcMain, updateManager) {
-  const dispatch = createUpdateDispatch(updateManager);
-  for (const [name, handler] of Object.entries(dispatch)) {
-    ipcMain.handle(`${IPC_PREFIX}${name}`, (_event, payload) => handler(payload));
-  }
-  return dispatch;
-}
-
-/** Send a no-payload ping to whichever window currently has focus (falling
- *  back to the first open window so a menu click still does something when
- *  triggered via a global accelerator with no window focused, e.g. right
- *  after 'activate' on mac). Used for the two accelerators that have no
- *  built-in Electron role — "new chat" and "search" are renderer state, not
- *  something main.js can act on directly. */
-function sendToFocusedWindow(BrowserWindow, channel) {
-  const win = BrowserWindow.getFocusedWindow() || BrowserWindow.getAllWindows()[0];
-  if (win && !win.isDestroyed()) win.webContents.send(channel);
-}
-
-/**
- * Deliver a resolved deep link to one window over DEEP_LINK_CHANNEL. A cold
- * launch (`aegis://…` handed to the OS while the app wasn't running) reaches
- * this before the renderer script has run `aegis.onDeepLink(...)` — sending
- * immediately would be lost, so a still-loading page gets the payload queued
- * for its first 'did-finish-load' instead of sent right away.
- */
-function sendDeepLinkToWindow(win, parsed) {
-  if (!win || win.isDestroyed() || !parsed) return;
-  const deliver = () => {
-    if (!win.isDestroyed()) win.webContents.send(DEEP_LINK_CHANNEL, parsed);
-  };
-  if (win.webContents.isLoadingMainFrame()) {
-    win.webContents.once('did-finish-load', deliver);
-  } else {
-    deliver();
-  }
-}
-
-/** Application menu: the platform defaults (Edit roles, mac's app/quit
- *  items) plus the native-shell accelerators this plan adds — New Chat
- *  (Cmd/Ctrl+N), Search (Cmd/Ctrl+K, opens the memory/session search
- *  overlay), Reload (Cmd/Ctrl+R) and Toggle DevTools (Cmd/Ctrl+Shift+I) are
- *  plain Electron roles that already carry the right accelerator on every
- *  platform — plus a manual "Check for Updates…" entry, since the automatic
- *  checks in createUpdateManager.start() only run on ready and every few
- *  hours, and an About item (mac gets one for free in the app submenu; other
- *  platforms get a Help menu — role 'about' shows app.setAboutPanelOptions()
- *  cross-platform since Electron 15). */
-function buildAppMenu({ app, Menu, BrowserWindow, updateManager }) {
-  const isMac = process.platform === 'darwin';
-
-  app.setAboutPanelOptions({
-    applicationName: app.getName(),
-    applicationVersion: app.getVersion(),
-    version: app.getVersion(),
-  });
-
-  const checkForUpdatesItem = {
-    label: 'Check for Updates…',
-    // Announced: a menu click is a user asking, so a failure is reported to
-    // them instead of being swallowed the way the background check prefers.
-    click: () => updateManager.check({ announce: true }),
-  };
-  const newChatItem = {
-    label: 'New Chat',
-    accelerator: 'CmdOrCtrl+N',
-    click: () => sendToFocusedWindow(BrowserWindow, MENU_NEW_CHAT_CHANNEL),
-  };
-  const searchItem = {
-    label: 'Search…',
-    accelerator: 'CmdOrCtrl+K',
-    click: () => sendToFocusedWindow(BrowserWindow, MENU_SEARCH_CHANNEL),
-  };
-  // Neither item knows the open session id — that's renderer state — so, like
-  // newChatItem/searchItem above, the click just pings the renderer, which
-  // calls window.aegis.exportSession() with its own currentSessionId. "Save
-  // as…" writes the human-readable Markdown form; "Export Session…" writes
-  // the raw JSON record (round-trippable, e.g. for re-import).
-  const saveAsItem = {
-    label: 'Save as…',
-    accelerator: 'CmdOrCtrl+S',
-    click: () => sendToFocusedWindow(BrowserWindow, MENU_EXPORT_MARKDOWN_CHANNEL),
-  };
-  const exportSessionItem = {
-    label: 'Export Session…',
-    click: () => sendToFocusedWindow(BrowserWindow, MENU_EXPORT_JSON_CHANNEL),
-  };
-  const fingerprintItem = {
-    label: 'Authorship Panel…',
-    click: () => sendToFocusedWindow(BrowserWindow, MENU_FINGERPRINT_CHANNEL),
-  };
-
-  const template = [
-    ...(isMac
-      ? [
-          {
-            label: app.getName(),
-            submenu: [
-              { role: 'about' },
-              checkForUpdatesItem,
-              { type: 'separator' },
-              { role: 'services' },
-              { type: 'separator' },
-              { role: 'hide' },
-              { role: 'hideOthers' },
-              { role: 'unhide' },
-              { type: 'separator' },
-              { role: 'quit' },
-            ],
-          },
-        ]
-      : []),
-    {
-      label: 'File',
-      submenu: [
-        newChatItem,
-        { type: 'separator' },
-        saveAsItem,
-        exportSessionItem,
-        { type: 'separator' },
-        ...(isMac ? [] : [checkForUpdatesItem, { type: 'separator' }]),
-        isMac ? { role: 'close' } : { role: 'quit' },
-      ],
-    },
-    {
-      label: 'Edit',
-      submenu: [
-        { role: 'undo' },
-        { role: 'redo' },
-        { type: 'separator' },
-        { role: 'cut' },
-        { role: 'copy' },
-        { role: 'paste' },
-        { role: 'selectAll' },
-      ],
-    },
-    {
-      label: 'View',
-      submenu: [
-        searchItem,
-        { type: 'separator' },
-        fingerprintItem,
-        { type: 'separator' },
-        { role: 'reload', accelerator: 'CmdOrCtrl+R' },
-        { role: 'forceReload' },
-        { type: 'separator' },
-        { role: 'toggleDevTools', accelerator: 'CmdOrCtrl+Shift+I' },
-      ],
-    },
-    ...(isMac
-      ? []
-      : [
-          {
-            label: 'Help',
-            submenu: [{ role: 'about' }],
-          },
-        ]),
-  ];
-  return Menu.buildFromTemplate(template);
-}
-
-// ---------------------------------------------------------------------------
-// Electron-only bootstrap
-// ---------------------------------------------------------------------------
-
-function bootstrap() {
-  const { app, BrowserWindow, ipcMain, safeStorage, shell, Menu, Notification, screen, dialog, globalShortcut } = electron;
-
-  // A container/CI/headless server with no usable GPU crashes Chromium's GPU
-  // process in a retry loop that ends in a FATAL exit ("GPU process isn't
-  // usable. Goodbye.") — and that happens BEFORE app.whenReady() ever fires,
-  // so autoProvisionApiKey() (the free device key + welcome-trial grant)
-  // never runs either: `npm install -g aegis-desktop && aegis` on exactly
-  // that class of machine registered nothing, with no error a user could
-  // act on. Must be called before the app is ready (Electron's own
-  // constraint); software rendering is a fine tradeoff for a text/chat UI
-  // with no WebGL or video.
-  //
-  // disableHardwareAcceleration() alone was not enough on a container whose
-  // Mesa/VA-API/DRI stack is fully broken rather than merely GPU-less:
-  // Chromium still spawned a GPU process for the SwiftShader software path,
-  // and that crash-looped to the same FATAL exit, just after a longer delay
-  // (measured: survived past 15s, died at ~44s). These three switches tell
-  // Chromium to skip GPU-process creation entirely rather than retry it
-  // under software rendering — the documented combination for Electron under
-  // Docker/CI/headless Linux.
-  app.disableHardwareAcceleration();
-  app.commandLine.appendSwitch('disable-gpu');
-  app.commandLine.appendSwitch('disable-software-rasterizer');
-  app.commandLine.appendSwitch('disable-gpu-compositing');
-
-  // A second launch (double-clicking the icon again, `aegis` from a second
-  // terminal, …) must focus the existing window, not spawn a second process
-  // fighting the first over the same on-disk settings/session/queue files —
-  // see the 'second-instance' handler below, registered once the window
-  // machinery it calls (createWindow/openWindows) exists later in this
-  // function (safe: the event only fires well after bootstrap() returns).
-  //
-  // A second launch is also how an aegis:// link reaches an already-running
-  // app on Windows/Linux: the OS starts a second process with the URL on its
-  // argv, requestSingleInstanceLock() hands that argv to 'second-instance' on
-  // *this* process below, and the second process exits here.
-  if (!app.requestSingleInstanceLock()) {
-    app.quit();
-    return;
-  }
-
-  app.setName('AEGIS Desktop');
-
-  // Read ~/.aegiscode/.env into process.env once, before anything resolves a
-  // key (resolveStartupKey() later in this function, and every BYOK provider
-  // key in lib/local/engine.js). A variable already exported in the launching
-  // shell always wins — see loadEnvFile()'s contract. Failure is never fatal:
-  // an absent file is the pre-existing state, not an error.
-  if (envFile && typeof envFile.loadEnvFile === 'function') {
-    try {
-      const envResult = envFile.loadEnvFile();
-      if (envResult.loose) {
-        console.warn(
-          `aegis: ${envResult.file} is readable by other accounts ` +
-            `(mode ${envResult.mode.toString(8)}) — consider \`chmod 600\` on it.`
-        );
-      }
-    } catch (e) {
-      console.warn(`aegis: could not read ${envFile.envFileFor()}: ${e && e.message}`);
-    }
-  }
-
-  // Register the aegis:// scheme so the OS routes those links to this app.
-  // Safe to call unconditionally (idempotent) and before 'ready'.
-  app.setAsDefaultProtocolClient(deepLink.PROTOCOL);
-
-  // macOS delivers a registered scheme via 'open-url', not argv — must be
-  // listened for before 'ready' or an activation during launch is dropped.
-  // A cold launch (app not yet running) races this handler against
-  // createWindow() below, so the parsed link is stashed and flushed once the
-  // first window exists; a warm launch (already running) delivers straight
-  // to the focused window, mirroring 'second-instance' below.
-  let pendingDeepLink = deepLink.parseDeepLinkArgv(process.argv);
-  app.on('open-url', (event, url) => {
-    event.preventDefault();
-    const parsed = deepLink.parseDeepLinkUrl(url);
-    if (!parsed) return;
-    const win = BrowserWindow.getFocusedWindow() || BrowserWindow.getAllWindows()[0];
-    if (win) sendDeepLinkToWindow(win, parsed);
-    else pendingDeepLink = parsed;
-  });
-
-  const aegis = createClient(credentials.clientOptions());
-  const dataDir = resolveUserDataDir(app);
-
-  // 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, settingsDir, settings } = createEngine(aegis, {
-    app,
-    safeStorage,
-    dir: dataDir,
-  });
-
-  // Resolve/auto-provision the account key as early as possible — BEFORE
-  // app.whenReady(), not inside it. autoProvisionApiKey() is a plain Node
-  // fetch call with no Electron dependency: createClient(credentials.
-  // clientOptions()) above already resolved any existing key (env, the
-  // shared file, the env-file fallback) onto `aegis.apiKey`, so this is a
-  // genuine registerDevice call only on a truly fresh install — the same
-  // one-call-is-enough guarantee autoProvisionApiKey() provides to the CLI
-  // and the MCP plugin. It persists straight to the plain shared
-  // credentials file via credentials.saveApiKey(), not safeStorage.
-  //
-  // Why this can't wait for 'ready': a container/CI host with a broken
-  // graphics stack crashes Chromium's GPU process in a retry loop that can
-  // end in a FATAL exit (see disableHardwareAcceleration above) BEFORE
-  // whenReady() ever resolves — measured here surviving 15s before dying at
-  // 42-44s even with hardware acceleration and GPU compositing disabled.
-  // Gating registration on 'ready' meant that exact class of host — exactly
-  // what `npm install -g aegis-desktop && aegis` on a headless server lands
-  // on — registered nothing and left no trace. Running it here means the
-  // account exists and the key is on disk the moment the process starts,
-  // independent of whether the window ever manages to open.
-  //
-  // Not calling settings.setAegisKey() here: safeStorage is not safe to use
-  // before 'ready' (see migrateLegacyAegisKey's own comment in desktop/lib/
-  // settings.js, the one other place in this codebase that already had to
-  // reason about this). The
-  // existing app.whenReady() block further down already re-reads the shared
-  // store via credentials.preferNewest() and writes the encrypted copy once
-  // ready — this just guarantees there is something there for it to find
-  // even when 'ready' never comes.
-  const accountKey = createAccountKey({
-    aegis,
-    credentials,
-    persistKey: (key) => settings.setAegisKey(key),
-    provision: (client, creds) => autoProvision.autoProvisionApiKey(client, creds, { app: 'desktop' }),
-    describeFailure: autoProvision.provisionFailureText,
-    onChange: (state) => broadcastAccountStatus(state),
-  });
-
-  // Google sign-in + Drive connect (lib/google-connect.js). Same key store as
-  // accountKey above (settings.setAegisKey) — one saved key, whichever door
-  // last wrote it — and the same banner: a successful Google sign-in clears
-  // whatever "no key" state accountKey was showing, same as a successful
-  // register-device retry does.
-  const googleConnect = createGoogleConnect({
-    aegis,
-    credentials,
-    persistKey: (key) => settings.setAegisKey(key),
-    openUrl: (url) => {
-      if (!isSafeExternalUrl(url)) return false;
-      shell.openExternal(url);
-      return true;
-    },
-    googleSignIn,
-    driveConnect: driveConnectLib,
-    driveUpload: driveUploadLib,
-    onAccountChange: () => broadcastAccountStatus(accountKey.status()),
-  });
-  const keyPresentAtStart = Boolean(aegis.apiKey);
-  const earlyKeyProvision = autoProvision.autoProvisionApiKey(aegis, credentials, { app: 'desktop' }).then((result) => {
-    accountKey.recordStartup(result);
-    if (!result.key && !aegis.apiKey) {
-      const reason =
-        (result.error && (result.error.status || result.error.message || String(result.error))) ||
-        'no key returned';
-      console.warn(`auto-provision: no account key from register-device (${reason})`);
-    }
-    return result;
-  });
-
-  // A provider key typed in the Settings pane used to reach ONLY this app's
-  // encrypted store, so `aegiscode` (the CLI) and the MCP plugin never saw it:
-  // same machine, same provider, key asked for twice, and a key entered here
-  // was gone from every other host on the next run. Mirror every key write into
-  // the shared `~/.aegiscode/.env` — the one file all four hosts read at
-  // start-up (loadEnvFile() above; cli/bin/aegiscode.js before the CLI runs) —
-  // so "add the key in the app" and "put it in ~/.aegiscode/.env" are the same
-  // instruction. The encrypted store stays this app's authority; the file is
-  // what makes the key exist for the others. The AEGIS *account* key is
-  // deliberately not mirrored: it is already shared via credentials.json, and a
-  // second copy is a second authority that can disagree (see the module's
-  // header). Wrapped before registerModelIpc below, so every IPC path uses the
-  // wrapped store.
-  try {
-    const { wrapProviderKeyMirror } = require('./lib/provider-key-mirror.js');
-    const onWarn = (m) => console.warn(`aegis: ${m}`);
-    wrapProviderKeyMirror(settings, envFile, { onWarn });
-    if (engine && engine.settings && engine.settings !== settings) {
-      wrapProviderKeyMirror(engine.settings, envFile, { onWarn });
-    }
-  } catch (e) {
-    // Never fatal: the store still works, only the cross-host copy is missing.
-    console.warn(`aegis: could not wire the shared env-file key mirror: ${e && e.message}`);
-  }
-
-  // Persist the in-app AEGIS key in its own reserved namespace, encrypted —
-  // never as a provider named 'aegis' (that coupling let the Settings pane's
-  // "Remove" delete the AEGIS key; defect #1).
-  //
-  // Mirrored into the shared 0600 store as well, so one sign-in covers this app,
-  // `aegiscode` and the MCP plugin instead of each host needing its own. The
-  // app's copy stays the encrypted one; resolveStartupKey() compares their
-  // `savedAt` stamps so whichever host wrote last is the key in force.
-  const persistApiKey = (key) => {
-    const result = settings.setAegisKey(key);
-    // NOT mirrored into ~/.aegiscode/.env on purpose — the line below already
-    // shares this key with every host (credentials.json, 0600, read by the CLI,
-    // the MCP plugin and this app). Two stores for one account key is two
-    // answers to "which key is in force"; see desktop/lib/provider-key-mirror.js.
-    if (key) credentials.saveApiKey(key);
-    else credentials.clearApiKey();
-    return result;
-  };
-
-  // Native "reply ready" notification: main.js is exactly where every
-  // chatCompletion/model:chat call already resolves (withReplyNotify above),
-  // so this is the one place that can tell whether the window that asked for
-  // it is still the one in front. Fires only when that window is
-  // minimized/hidden/unfocused; a foregrounded chat needs no OS-level nudge.
-  // Notification.isSupported() gates platforms/sandboxes with no native
-  // notification centre so this never throws.
-  function notifyReplyIfUnfocused(event) {
-    const sender = event && event.sender;
-    const win = sender && BrowserWindow.fromWebContents(sender);
-    if (!win || win.isDestroyed()) return;
-    if (win.isFocused() && win.isVisible()) return;
-    if (!Notification || !Notification.isSupported()) return;
-    const note = new Notification({ title: 'AEGIS Desktop', body: 'Reply ready' });
-    note.on('click', () => {
-      if (win.isDestroyed()) return;
-      if (win.isMinimized()) win.restore();
-      if (!win.isVisible()) win.show();
-      win.focus();
-    });
-    note.show();
-  }
-
-  // Both automations (lib/auto.js) are built further down, AFTER the queue and
-  // the fingerprint have been wired — they call into both. This `let` is how
-  // the reply hook below (which has to be handed to registerIpc up here) can
-  // reach one that does not exist yet: it fires when a turn FINISHES, which is
-  // always long after bootstrap() has returned, and it is null-guarded so a
-  // reply arriving in that theoretical gap is a no-op rather than a TypeError.
-  let autoMint = null;
-
-  /**
-   * The reply hook: the native notification (unchanged) plus the auto-mint's
-   * quiet clock. The clock is restarted by every finished turn, never read as
-   * "seal now" — lib/auto.js's flush() is what decides, and only once the
-   * session has been quiet for its full interval.
-   */
-  const handleReplyFinished = (event, result) => {
-    notifyReplyIfUnfocused(event);
-    if (autoMint && typeof autoMint.note === 'function') {
-      autoMint.note({ sessionId: (result && result.sessionId) || null });
-    }
-  };
-
-  registerIpc(
-    ipcMain,
-    aegis,
-    dataDir,
-    persistApiKey,
-    (url) => shell.openExternal(url),
-    handleReplyFinished,
-    () => providerRouteConfigured(engine),
-    () => settings.vaultBackendConfig().backend
-  );
-  const modelIpc = registerModelIpc(
-    ipcMain,
-    engine,
-    sessionsDir,
-    aegis,
-    handleReplyFinished,
-    undefined,
-    settingsDir
-  );
-
-  // Tool-call approval toggle (Settings → "Confirm before running tools"):
-  // aegis:getConfirmMode / aegis:setConfirmMode. Registered here because this
-  // 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).
-  //
-  // …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));
-
-  // Vault backend preference (Settings/the authorship panel → Google Drive /
-  // AE / No sync): aegis:getVaultBackend / aegis:setVaultBackend. Registered
-  // here, beside confirm mode, for the same reason — this is where the
-  // settings store lands, and lib/fingerprint.js's vaultScope()/vaultDisabled()
-  // read the live value through the getVaultBackend thunks passed to
-  // registerIpc and createAutoMint above, so a change here reaches the very
-  // next publish/anchor/vault/audit call with no restart.
-  registerConfirmModeIpc(ipcMain, createVaultBackendDispatch(settings));
-
-  // Funnel instrumentation (Phase 2 of docs/upgrade-conversion-plan.md):
-  // aegis:telemetryEvent / aegis:telemetryReport, backed by
-  // lib/local/telemetry.js.
-  //
-  // OFF unless the operator opted in — `AEGIS_TELEMETRY=1` in the environment
-  // (or ~/.aegiscode/.env, which the shared loader is read from elsewhere in
-  // this file) or `settings.setTelemetryOptIn(true)`. A disabled store is a
-  // pure no-op: no directory, no install id, no writes.
-  //
-  // TRANSPORT: local-first, because aegis1 has no route that accepts
-  // client-named funnel events (see the header of lib/local/telemetry.js).
-  // Nothing is sent anywhere today; records land in
-  // `<userData>/telemetry/funnel.jsonl`, and scripts/funnel-report.mjs turns
-  // them into the baseline table. The module's `sender` option is the seam for
-  // the server half, unused while no endpoint exists.
-  const telemetry = createTelemetry({
-    dir: settingsDir,
-    enabled: telemetryEnabled(process.env, settings),
-    appVersion: (() => {
-      try {
-        return typeof app.getVersion === 'function' ? app.getVersion() : '';
-      } catch {
-        return '';
-      }
-    })(),
-  });
-  registerTelemetryIpc(ipcMain, createTelemetryDispatch(telemetry));
-
-  // ÆGIS covenant (ÆL/1), READ-ONLY: aegis:covenantStatus / aegis:covenantGapReport
-  // expose the decoded seal for display. The enforcing half is not here — it is
-  // the unconditional pre-action assert inside engine.guardedExecute, which no
-  // renderer request, approval or config flag can reach or skip (§9 invariant
-  // ¬M(Λ1) ∧ ¬M(Λ2) ∧ ¬M(Λ4)).
-  registerCovenantIpc(ipcMain, createCovenantDispatch(covenantModule));
-
-  // Local autonomous work queue: queue:<name> on ipcMain, backed by the durable
-  // queue file (desktop/lib/local/queue.js — the SAME file the `aegiscode` CLI
-  // and the other hosts read) and the unattended worker
-  // (desktop/lib/local/autonomous.js).
-  //
-  // It gets its OWN engine, built with the approval gate off: a queued task has
-  // nobody to answer a card, so the interactive engine is the wrong one to hand
-  // a worker (see createQueueEngine).
-  //
-  // Registration alone drains nothing. Two ways a drain starts: the queue
-  // card's Run one / Drain all (the card is hidden now, but the IPC and the
-  // CLI entry point are the same call), or the background worker below — a
-  // PERSISTED setting (settings.js `__autoDrain`), ON unless explicitly
-  // switched off, read by lib/auto.js on every tick. There is still no boot
-  // drain and no drain-on-idle: the first tick is one interval after start.
-  const queueDispatch = registerQueueIpc(ipcMain, {
-    engine: createQueueEngine(aegis, settings),
-    aegis,
-  });
-
-  // ── the two opt-in automations (lib/auto.js) ─────────────────────────────
-  //
-  // Created here because this is the first point where every collaborator
-  // exists: settings (the switches), the queue dispatch above (the drain), and
-  // the fingerprint service (the seal). What they do NOT get is a vote — both
-  // modules re-read the persisted switch on every tick, so flipping the toggle
-  // in the card or the panel stops the very next one.
-  const autoDrain = createAutoDrain({
-    // The SAME entry point the card's "Drain all" button calls
-    // (createQueueDispatch's `proceed` -> drainAll). Not a second loop: the
-    // worker's own per-task lock, Stop, and the progress frames are all the
-    // ones the button already uses.
-    proceed: () => queueDispatch.proceed(),
-    settings,
-    queue: queueModule,
-    env: process.env,
-    log: (entry) => {
-      // Visible in the main-process log, and nowhere else. An automation that
-      // fails silently is indistinguishable from one that is switched off.
-      if (entry && entry.type !== 'skip') console.log('[auto-drain]', entry.type, entry.reason || entry.error || '');
-    },
-  });
-
-  // The seal. `mint` is lib/fingerprint.js's own — the same call the panel's
-  // "Seal this session" makes, reading the same session log through the same
-  // shared adapter. The service is built LAZILY for the reason createIpcDispatch
-  // states: a broken shared module must surface as an error in the panel, not as
-  // a window that never opens. `aiSecret` is never passed, so the AI axis of the
-  // record is attested from `$AEGIS_AI_SECRET` in the app's scope by
-  // client/attest.js's own rungs — no key enters main.js, the settings store, or
-  // the DOM for this path.
-  let autoFingerprint = null;
-  autoMint = createAutoMint({
-    mint: (payload) => {
-      if (!autoFingerprint) {
-        autoFingerprint = createFingerprintService({
-          dir: dataDir,
-          getVaultBackend: () => settings.vaultBackendConfig().backend,
-        });
-      }
-      return autoFingerprint.mint(payload || {});
-    },
-    settings,
-  });
-
-  registerAutoIpc(ipcMain, createAutoDispatch({ autoDrain, autoMint }));
-
-  // Arm the background workers. Both start() calls are reads of a persisted
-  // setting that is ON unless it was explicitly switched off (settings.js
-  // `__autoDrain`/`__autoMint`), so a default install drains a queued task with
-  // no click and seals a quiet session with nothing on screen. Neither start()
-  // drains or seals anything by itself: the drain's first tick is one interval
-  // away and the mint waits for a finished turn before its quiet clock starts.
-  autoDrain.start();
-  autoMint.start();
-
-  // ---------------------------------------------------------------------
-  // Global quick-launcher (D? quick launcher): a frameless, always-on-top,
-  // taskbar-hidden popup toggled by a systemwide shortcut, for a one-shot
-  // question without switching to (or even seeing) the main window.
-  // ---------------------------------------------------------------------
-
-  // Set by createWindow() below once the main window exists; read by
-  // pushQuickLauncherResult() to know where a "add to chat" push should land.
-  // `let` (not `const`) because createWindow() can run more than once
-  // (macOS 'activate' with no windows open, a 'second-instance' relaunch).
-  let mainWindowRef = null;
-  let quickWin = null;
-
-  function getOrCreateQuickLauncherWindow() {
-    if (quickWin && !quickWin.isDestroyed()) return quickWin;
-    quickWin = new BrowserWindow({
-      width: 560,
-      height: 320,
-      show: false,
-      frame: false,
-      alwaysOnTop: true,
-      skipTaskbar: true,
-      resizable: false,
-      movable: true,
-      fullscreenable: false,
-      minimizable: false,
-      maximizable: false,
-      backgroundColor: '#0d1117',
-      icon: iconForPlatform(resolveIconsDir(app.isPackaged, process.resourcesPath, __dirname), process.platform),
-      webPreferences: {
-        preload: path.join(__dirname, 'preload.js'),
-        contextIsolation: true,
-        nodeIntegration: false,
-        sandbox: true,
-      },
-    });
-    quickWin.setMenuBarVisibility(false);
-    quickWin.loadFile(path.join(__dirname, 'renderer', 'quick.html'));
-
-    // Escape hides it. Caught at the Electron input-event level (rather than
-    // a renderer keydown -> IPC round trip) so there is exactly one place —
-    // here — that decides what "hide" means, matching the blur handler right
-    // below: plain win.hide(), nothing more. Neither path ever calls
-    // mainWindowRef.focus() or otherwise touches the main window, so hiding
-    // the launcher — by Escape, by blur, or by pressing the toggle shortcut
-    // again — can never steal focus from whatever window had it before the
-    // launcher opened.
-    quickWin.webContents.on('before-input-event', (_event, input) => {
-      if (input.type === 'keyDown' && input.key === 'Escape' && !quickWin.isDestroyed()) {
-        quickWin.hide();
-      }
-    });
-    // Click-away / Alt-Tab away hides it too — a launcher that stays pinned
-    // on screen after the user's attention has moved on is just clutter.
-    quickWin.on('blur', () => {
-      if (!quickWin.isDestroyed() && quickWin.isVisible()) quickWin.hide();
-    });
-    quickWin.on('closed', () => {
-      quickWin = null;
-    });
-    return quickWin;
-  }
-
-  function toggleQuickLauncher() {
-    const win = getOrCreateQuickLauncherWindow();
-    if (win.isVisible()) {
-      win.hide();
-      return;
-    }
-    const cursor = screen.getCursorScreenPoint();
-    const displays = screen.getAllDisplays();
-    const current = win.getBounds();
-    const bounds = quickLauncherLib.computeQuickLauncherBounds({
-      cursor,
-      displays,
-      size: { width: current.width, height: current.height },
-    });
-    win.setBounds(bounds);
-    win.show();
-    win.focus();
-  }
-
-  /**
-   * (Re)register the global shortcut for `{ enabled, shortcut }`, or
-   * unregister it when this build/config doesn't want one active (dev run,
-   * flag off). `globalShortcut.unregisterAll()` is safe here — this app
-   * registers no other global accelerators (the menu's Cmd/Ctrl+N etc. are
-   * plain Electron Menu roles, local to the focused window, not
-   * globalShortcut). Never throws: a taken accelerator or an invalid
-   * accelerator string both degrade to `{ active: false, reason }` with a
-   * console.warn, exactly per the "gracefully degrading" requirement — a
-   * bad shortcut must never crash the app or block it from starting.
-   */
-  function applyQuickLauncherConfig(cfg) {
-    globalShortcut.unregisterAll();
-    if (!quickLauncherLib.shouldEnableGlobalShortcut({ isPackaged: app.isPackaged, enabled: cfg.enabled })) {
-      return { active: false, reason: null };
-    }
-    try {
-      const ok = globalShortcut.register(cfg.shortcut, toggleQuickLauncher);
-      if (!ok) {
-        const reason = `"${cfg.shortcut}" could not be registered — it may already be in use by another application.`;
-        console.warn(`[quick-launcher] ${reason}`);
-        return { active: false, reason };
-      }
-      return { active: true, reason: null };
-    } catch (err) {
-      const reason = errorText(err);
-      console.warn(`[quick-launcher] failed to register shortcut "${cfg.shortcut}": ${reason}`);
-      return { active: false, reason };
-    }
-  }
-
-  /**
-   * `quick:pushToMain` — the launcher's "add to chat" keystroke. Hides the
-   * launcher window that sent the request (never the reverse: the main
-   * window is never hidden), delivers the payload to the main window over
-   * QUICK_LAUNCHER_PUSH_CHANNEL (whose handler in renderer/app.js owns
-   * actually building the chat turn — same "renderer owns the state" split
-   * as every other menu-ping channel in this file), then brings the main
-   * window forward so the user lands where the new turn appeared.
-   */
-  function pushQuickLauncherResult(payload, event) {
-    const senderWin = event && event.sender && BrowserWindow.fromWebContents(event.sender);
-    if (senderWin && !senderWin.isDestroyed()) senderWin.hide();
-    const target =
-      mainWindowRef && !mainWindowRef.isDestroyed()
-        ? mainWindowRef
-        : BrowserWindow.getAllWindows().find((w) => w !== senderWin) || null;
-    if (!target) return { ok: false, reason: 'no main window is open' };
-    target.webContents.send(QUICK_LAUNCHER_PUSH_CHANNEL, payload || {});
-    if (target.isMinimized()) target.restore();
-    if (!target.isVisible()) target.show();
-    target.focus();
-    return { ok: true };
-  }
-
-  const quickLauncherDispatch = createQuickLauncherDispatch(settings, {
-    isPackaged: app.isPackaged,
-    applyConfig: applyQuickLauncherConfig,
-    pushToMain: pushQuickLauncherResult,
-  });
-  registerQuickLauncherIpc(ipcMain, quickLauncherDispatch);
-
-  // A held global shortcut outlives this app if not released — every quit
-  // path (explicit quit, window-all-closed on non-mac, OS shutdown) must
-  // free it.
-  // The presence beacon (aegis1 /api/v1/heartbeat), held here so the quit path
-  // can stop it. `null` until `app.whenReady` starts it: the beacon needs the
-  // resolved account key, and a `let` (not a `const`) because a quit can
-  // precede a successful start.
-  let presenceBeacon = null;
-
-  app.on('will-quit', () => {
-    // Beacon timers are unref'd, so this is not what keeps the process alive —
-    // it is what stops a beat from being sent while Electron tears the process
-    // down under it.
-    if (presenceBeacon && typeof presenceBeacon.stop === 'function') presenceBeacon.stop();
-    globalShortcut.unregisterAll();
-    // The update manager's retry/interval timers are unref'd so they never
-    // hold the process open, but an explicit quit should still cancel them
-    // rather than let one land during teardown.
-    if (updateManager && typeof updateManager.stop === 'function') updateManager.stop();
-  });
-
-  // Unload any local model this app warmed (engine.js `unloadLocalModels` ->
-  // local.js `unloadAll`) BEFORE the process actually exits — "closing the
-  // app closes the model" is the point, since a model left loaded on the
-  // user's own hardware after the app is gone is pure waste with no UI left
-  // to even show it's happening. `will-quit` above is synchronous-only and
-  // fires too late for this (the process is already tearing down), so this
-  // intercepts the FIRST quit request, does the async cleanup, then lets a
-  // second, real quit through — the standard Electron pattern for async work
-  // on the quit path. Bounded by `unload`'s own per-request timeout inside
-  // `unloadAll`, so a dead or slow daemon can never be the reason closing the
-  // window hangs.
-  let quitCleanly = false;
-  app.on('before-quit', (event) => {
-    if (quitCleanly || !engine || typeof engine.unloadLocalModels !== 'function') return;
-    event.preventDefault();
-    Promise.resolve()
-      .then(() => engine.unloadLocalModels())
-      .catch(() => {})
-      .finally(() => {
-        quitCleanly = true;
-        app.quit();
-      });
-  });
-
-  // electron-updater touches the network and expects a build-time
-  // app-update.yml that only exists in a packaged app; requiring it is safe
-  // either way, but it's wrapped defensively so a version mismatch or a
-  // missing optional native dep degrades to "updates disabled" instead of
-  // taking the whole app down.
-  let realAutoUpdater = null;
-  try {
-    realAutoUpdater = require('electron-updater').autoUpdater;
-  } catch {
-    realAutoUpdater = null;
-  }
-
-  const openWindows = new Set();
-  function broadcastUpdateStatus(state) {
-    for (const win of openWindows) {
-      if (!win.isDestroyed()) win.webContents.send(UPDATE_STATUS_CHANNEL, state);
-    }
-  }
-  function broadcastAccountStatus(state) {
-    for (const win of openWindows) {
-      if (!win.isDestroyed()) win.webContents.send(ACCOUNT_STATUS_CHANNEL, state);
-    }
-  }
-
-  const updateManager = createUpdateManager({
-    autoUpdater: realAutoUpdater,
-    isPackaged: app.isPackaged,
-    onStatus: broadcastUpdateStatus,
-  });
-  registerUpdateIpc(ipcMain, updateManager);
-  ipcMain.handle(`${IPC_PREFIX}accountStatus`, () => accountKey.status());
-  ipcMain.handle(`${IPC_PREFIX}registerAccount`, () => accountKey.registerAccount());
-  // Google sign-in + Drive connect/sync (lib/google-connect.js). Every call
-  // resolves `{ ok, … }` / `{ ok: false, error }` rather than throwing, same
-  // contract as the fingerprint* handlers below — the renderer shows the
-  // actual reason instead of Electron's opaque "Error invoking remote method".
-  ipcMain.handle(`${IPC_PREFIX}driveSignIn`, () => googleConnect.signInWithGoogle());
-  ipcMain.handle(`${IPC_PREFIX}driveConnect`, () => googleConnect.connectDrive());
-  ipcMain.handle(`${IPC_PREFIX}driveStatus`, () => googleConnect.status());
-  ipcMain.handle(`${IPC_PREFIX}driveSyncMemory`, () => googleConnect.syncMemoryNow());
-  registerExportIpc(
-    ipcMain,
-    sessionStore,
-    sessionsDir,
-    (opts) => dialog.showSaveDialog(BrowserWindow.getFocusedWindow(), opts),
-    (filePath, content) => fs.promises.writeFile(filePath, content, 'utf8')
-  );
-  Menu.setApplicationMenu(buildAppMenu({ app, Menu, BrowserWindow, updateManager }));
-
-  // The local file this window is allowed to be at — used both to restore a
-  // saved position/reload and to recognise (and block) any navigation away
-  // from it. pathToFileURL normalises the platform path separators so the
-  // will-navigate comparison below works identically on Windows.
-  const appUrl = pathToFileURL(path.join(__dirname, 'renderer', 'index.html')).href;
-
-  function createWindow() {
-    const defaultBounds = { width: 1080, height: 720 };
-    const saved = windowState.load(dataDir);
-    // A saved position from a monitor that's since been unplugged (or a
-    // resolution that shrank) must never place the window off every
-    // connected display — that's a window that "opens" but nobody can see
-    // or reach.
-    const bounds = windowState.clampToDisplay(saved, screen.getAllDisplays(), defaultBounds);
-    const iconsDir = resolveIconsDir(app.isPackaged, process.resourcesPath, __dirname);
-
-    const win = new BrowserWindow({
-      ...bounds,
-      minWidth: 720,
-      minHeight: 480,
-      backgroundColor: '#0d1117',
-      title: 'AEGIS Desktop',
-      icon: iconForPlatform(iconsDir, process.platform),
-      webPreferences: {
-        preload: path.join(__dirname, 'preload.js'),
-        contextIsolation: true,
-        nodeIntegration: false,
-        sandbox: true,
-        spellcheck: true,
-      },
-    });
-
-    if (saved && saved.isMaximized) win.maximize();
-
-    // Popups (window.open, target=_blank, a model-rendered link that isn't
-    // routed through the aegis:openExternal IPC method) never get a second
-    // BrowserWindow inside this app: an http/https URL goes to the OS
-    // browser, everything else (file://, javascript:, …) is dropped — same
-    // allowlist as isSafeExternalUrl above.
-    win.webContents.setWindowOpenHandler(({ url }) => {
-      if (isSafeExternalUrl(url)) shell.openExternal(url);
-      return { action: 'deny' };
-    });
-
-    // In-page navigation is likewise locked to this one local file. Without
-    // this, a compromised renderer script (or a link that reaches the
-    // BrowserWindow's own navigation instead of window.open) could carry the
-    // whole app to an arbitrary origin; http/https targets are hard-blocked
-    // here too, exactly like the popup case, and handed to the OS browser.
-    win.webContents.on('will-navigate', (navEvent, navigationUrl) => {
-      if (navigationUrl === appUrl) return;
-      navEvent.preventDefault();
-      if (isSafeExternalUrl(navigationUrl)) shell.openExternal(navigationUrl);
-    });
-
-    // Bounds persistence: debounced on resize/move (dragging fires dozens of
-    // events per second — writing a file on every one would be wasteful and
-    // would fight the OS for disk I/O mid-drag), and flushed unconditionally
-    // on close so the final size/position always lands. getNormalBounds() is
-    // used while maximized so un-maximizing next launch restores the pre-
-    // maximize rectangle instead of the full-screen one.
-    let saveBoundsTimer = null;
-    function persistBounds() {
-      if (win.isDestroyed()) return;
-      const isMaximized = win.isMaximized();
-      const rect = isMaximized ? win.getNormalBounds() : win.getBounds();
-      windowState.save(dataDir, { ...rect, isMaximized });
-    }
-    function scheduleBoundsSave() {
-      if (saveBoundsTimer) clearTimeout(saveBoundsTimer);
-      saveBoundsTimer = setTimeout(persistBounds, 500);
-    }
-    win.on('resize', scheduleBoundsSave);
-    win.on('move', scheduleBoundsSave);
-    win.on('close', () => {
-      if (saveBoundsTimer) clearTimeout(saveBoundsTimer);
-      persistBounds();
-    });
-
-    win.loadFile(path.join(__dirname, 'renderer', 'index.html'));
-    openWindows.add(win);
-    mainWindowRef = win;
-    win.on('closed', () => {
-      openWindows.delete(win);
-      if (mainWindowRef === win) mainWindowRef = null;
-    });
-    return win;
-  }
-
-  app.whenReady().then(async () => {
-    // Hydrate the client from the persisted key BEFORE the renderer issues any
-    // status/model call, so class/model dropdowns populate immediately when a
-    // key was saved in-app (safeStorage is usable only after app ready).
-    //
-    // `$AEGIS_API_KEY` still outranks both stores: createClient() already read
-    // it, and nothing here may shadow an explicit export.
-    const envKey = credentials.normalizeApiKey(process.env[credentials.KEY_ENV]);
-    if (!envKey) {
-      // Wait for the pre-ready attempt above rather than racing a second
-      // registerDevice call: autoProvisionApiKey() already ran (or is still
-      // running) the instant this process started, specifically so it is
-      // not gated on 'ready' — see the earlyKeyProvision comment above for
-      // why (a container with a broken graphics stack can crash before
-      // 'ready' ever fires). Swallowing a keyless outcome here was how a
-      // machine could sit absent from the admin panel's user list AND its
-      // presence card with no trace anywhere — the server now logs every
-      // registration attempt, and earlyKeyProvision's own .then() already
-      // warns on failure, so there is nothing further to report if it
-      // didn't land.
-      const early = await earlyKeyProvision;
-      // A key minted just now only means "no key was saved yet" — a key the user
-      // saved in Settings before the shared store mirrored it would otherwise be
-      // overwritten by the device's fresh account on this first start.
-      const override = startupKeyOverride({
-        mintedKey: keyPresentAtStart ? '' : early.key,
-        hostKey: credentials.normalizeApiKey(settings.aegisRawKey()),
-      });
-      if (override) {
-        credentials.saveApiKey(override);
-        aegis.setApiKey(override);
-      } else {
-        const chosen = credentials.preferNewest(settings.aegisRawKey(), settings.aegisKeySavedAt());
-        if (chosen.key) {
-          aegis.setApiKey(chosen.key);
-          // The shared store is the newer write: bring this host's encrypted copy
-          // up to date so a CLI rotation does not have to be redone in Settings.
-          if (chosen.source === 'shared') settings.setAegisKey(chosen.key);
-        }
-      }
-    }
-    // ── presence beacon ───────────────────────────────────────────────────
-    //
-    // aegis1's `/api/v1/heartbeat` (`heartbeat_v1`), the client half of the
-    // admin panel's presence card: which app, which build, which OS, how many
-    // machines, and whether a drain is running. Started HERE because it needs
-    // the account key and this is the first point where the key is final —
-    // resolved from env/the shared store, or auto-provisioned just above — so
-    // the very first beat carries the account the app is actually signed in
-    // with rather than a stale one. Stopped in `will-quit`.
-    //
-    // `install` is the machine fingerprint (client/device-fingerprint.js), the
-    // SAME identity the device-registration path uses: the panel's "how many
-    // machines" is only true if every beat from one laptop carries one id.
-    //
-    // A keyless app gets an inert store from presence.js — no timer, no
-    // request — so an offline or signed-out launch is silent rather than a 401
-    // loop. A beacon failure must never block the window from opening.
-    try {
-      if (presenceBeacon && typeof presenceBeacon.stop === 'function') presenceBeacon.stop();
-      presenceBeacon = sharedPresence.createPresence({
-        apiKey: aegis.apiKey,
-        // 'desktop' is one of the names aegis1's PRESENCE_APPS keeps; anything
-        // else it does not recognise is stored as 'other' with a 200 and no
-        // error anywhere. See client/presence-constants.js.
-        app: 'desktop',
-        version: app.getVersion(),
-        platform: process.platform,
-        install: sharedFingerprint.machineFingerprint(),
-        // Read at SEND time: the panel wants the queue as it is now, not the
-        // depth it happened to have at launch. Same queue file the CLI drains
-        // (`desktop/lib/local/queue.js` — see registerQueueIpc below).
-        queueDepth: () => {
-          try {
-            const items = queueModule.readQueue(queueModule.queuePath());
-            return items.filter((t) => t && t.status === 'pending').length;
-          } catch {
-            return 0;
-          }
-        },
-        // The desktop card's drain is renderer-driven today; there is no
-        // always-on worker in main to report, so this stays false rather than
-        // claiming a drain that is not running.
-        autonomous: false,
-        log: (level, message) => {
-          if (level !== 'debug') console.warn(message);
-        },
-      });
-      presenceBeacon.start();
-    } catch (err) {
-      console.warn('presence: beacon not started', err && err.message);
-    }
-    // One-way backfill of the cross-host key mirror. wrapProviderKeyMirror
-    // (above) is a WRITE-TIME hook: it only fires when a key is saved through
-    // this store, so every row that predates the hook — or was saved with the
-    // key field left blank ("keep the stored one", which mirrors nothing by
-    // design) — still lives only in this app's encrypted store and is invisible
-    // to the CLI and the MCP plugin. Running the reconcile here closes that gap
-    // once per launch, in the store -> file direction only, and skips any
-    // variable the shared file already carries. After app 'ready', because
-    // safeStorage (which decrypts the stored key) is unusable before then, and
-    // deliberately before createWindow() so the CLI's next run — not the next
-    // Save — is when the key becomes visible.
-    //
-    // Never fatal: the keys are already saved, and a failed copy to the shared
-    // file is a smaller problem than a window that does not open.
-    try {
-      const { backfillProviderKeys } = require('./lib/provider-key-mirror.js');
-      const onWarn = (m) => console.warn(`aegis: ${m}`);
-      const result = backfillProviderKeys(settings, envFile, { onWarn });
-      if (result.mirrored.length) {
-        console.warn(
-          `aegis: shared ${result.mirrored.join(', ')} key(s) with the other hosts `
-            + `(${envFile.envFileFor()})`
-        );
-      }
-      if (engine && engine.settings && engine.settings !== settings) {
-        backfillProviderKeys(engine.settings, envFile, { onWarn });
-      }
-    } catch (e) {
-      console.warn(`aegis: could not backfill the shared env-file key mirror: ${e && e.message}`);
-    }
-    // Apply whatever was last saved (or the default): ship the shortcut only
-    // when app.isPackaged || the settings flag is on — see
-    // shouldEnableGlobalShortcut — so a plain `electron .` dev run never
-    // grabs a systemwide hotkey unless the developer opted in from Settings.
-    // Must run after 'ready' — globalShortcut throws before then.
-    quickLauncherDispatch.setConfig(settings.quickLauncherConfig());
-    const win = createWindow();
-    updateManager.start();
-    // Cold-launch deep link (Linux/Windows argv, or a pre-ready macOS
-    // 'open-url'): the window didn't exist when it was parsed above, so
-    // deliver it now that one does.
-    if (pendingDeepLink) sendDeepLinkToWindow(win, pendingDeepLink);
-  });
-
-  app.on('window-all-closed', () => {
-    if (process.platform !== 'darwin') app.quit();
-  });
-
-  app.on('activate', () => {
-    if (BrowserWindow.getAllWindows().length === 0) createWindow();
-  });
-
-  // Second launch while already running: focus (and restore/show) the
-  // existing window instead of leaving the new process to just exit having
-  // done nothing visible. `argv` is the second process's argv — on
-  // Windows/Linux this is how an aegis:// link reaches an already-running
-  // app (see the 'open-url'/macOS comment above); the URL arrives as a bare
-  // positional entry (the Linux argv quirk deepLink.extractDeepLinkUrl scans
-  // for), not a named flag.
-  app.on('second-instance', (_event, argv) => {
-    const win = BrowserWindow.getAllWindows()[0];
-    const parsed = deepLink.parseDeepLinkArgv(argv);
-    if (!win) {
-      const created = createWindow();
-      if (parsed) sendDeepLinkToWindow(created, parsed);
-      return;
-    }
-    if (win.isMinimized()) win.restore();
-    if (!win.isVisible()) win.show();
-    win.focus();
-    if (parsed) sendDeepLinkToWindow(win, parsed);
-  });
-}
-
-if (electron && electron.app) {
-  bootstrap();
-}
-
-module.exports = {
-  createIpcDispatch,
-  registerIpc,
-  providerRouteConfigured,
-  IPC_PREFIX,
-  MODEL_PREFIX,
-  SYNC_PREFIX,
-  watchTopupCredit,
-  bankAmount,
-  TOPUP_POLL_MS,
-  TOPUP_POLL_TRIES,
-  CHAT_DELTA_CHANNEL,
-  MENU_NEW_CHAT_CHANNEL,
-  MENU_SEARCH_CHANNEL,
-  MENU_EXPORT_MARKDOWN_CHANNEL,
-  MENU_EXPORT_JSON_CHANNEL,
-  MENU_FINGERPRINT_CHANNEL,
-  DEEP_LINK_CHANNEL,
-  UPDATE_STATUS_CHANNEL,
-  UPDATE_CHECK_INTERVAL_MS,
-  taggedChunk,
-  maskKey,
-  createModelDispatch,
-  DESKTOP_CLASSES,
-  readTextFileForPreview,
-  PREVIEW_READ_MAX_BYTES,
-  createSyncDispatch,
-  registerModelIpc,
-  createHeartbeatRetry,
-  describeSyncError,
-  HEARTBEAT_RETRY_BASE_MS,
-  HEARTBEAT_RETRY_MAX_MS,
-  createEngine,
-  resolveUserDataDir,
-  importForeignMemory,
-  isSafeExternalUrl,
-  createUpdateManager,
-  createNpmUpdateManager,
-  createUpdateDispatch,
-  describeRegistryFailure,
-  UPDATE_RETRY_BACKOFF_MS,
-  registerUpdateIpc,
-  buildAppMenu,
-  createExportDispatch,
-  registerExportIpc,
-  safeExportBasename,
-  sendDeepLinkToWindow,
-  QUICK_PREFIX,
-  QUICK_LAUNCHER_PUSH_CHANNEL,
-  createQuickLauncherDispatch,
-  registerQuickLauncherIpc,
-  createConfirmModeDispatch,
-  createVaultBackendDispatch,
-  withAutoRoundsSwitch,
-  createTelemetryDispatch,
-  registerTelemetryIpc,
-  createCovenantDispatch,
-  registerCovenantIpc,
-  registerConfirmModeIpc,
-  QUEUE_PREFIX,
-  QUEUE_PROGRESS_CHANNEL,
-  QUEUE_MAX_TASK_CHARS,
-  QUEUE_MAX_ROUNDS,
-  createQueueEngine,
-  queueEngineWithDeniedApprovals,
-  createQueueDispatch,
-  registerQueueIpc,
-  AUTO_PREFIX,
-  createAutoDispatch,
-  registerAutoIpc,
-};
+"use strict";const path=require("node:path"),fs=require("node:fs"),{execFile:execFile}=require("node:child_process"),{pathToFileURL:pathToFileURL}=require("node:url");let sharedClient;try{sharedClient=require("../client/aegis.js")}catch{sharedClient=require("./vendor/aegis.js")}const{createClient:createClient}=sharedClient;let credentials,autoProvision,sharedPresence,sharedTopup,googleSignIn,driveConnectLib,driveUploadLib;try{credentials=require("../client/credentials.js")}catch{credentials=require("./vendor/credentials.js")}try{autoProvision=require("../client/auto-provision.js")}catch{autoProvision=require("./vendor/auto-provision.js")}try{sharedPresence=require("../client/presence.js")}catch{sharedPresence=require("./vendor/presence.js")}try{sharedTopup=require("../client/topup.js")}catch{sharedTopup=require("./vendor/topup.js")}try{googleSignIn=require("../client/google-signin.js")}catch{googleSignIn=require("./vendor/google-signin.js")}try{driveConnectLib=require("../client/drive-connect.js")}catch{driveConnectLib=require("./vendor/drive-connect.js")}try{driveUploadLib=require("../client/drive-upload.js")}catch{driveUploadLib=require("./vendor/drive-upload.js")}const{createGoogleConnect:createGoogleConnect}=require("./lib/google-connect.js");let sharedFingerprint;try{sharedFingerprint=require("../client/device-fingerprint.js")}catch{sharedFingerprint=require("./vendor/device-fingerprint.js")}const{createFingerprintService:createFingerprintService}=require("./lib/fingerprint.js"),{createAutoDrain:createAutoDrain,createAutoMint:createAutoMint}=require("./lib/auto.js");let envFile=null;try{envFile=require("../client/env-file.js")}catch{try{envFile=require("./vendor/env-file.js")}catch{}}let electron=null;try{electron=require("electron")}catch{}const os=require("node:os"),{createLocalEngine:createLocalEngine}=require("./lib/local/engine.js"),{createAccountKey:createAccountKey,startupKeyOverride:startupKeyOverride}=require("./lib/account-key.js"),{createSettingsStore:createSettingsStore,isReservedNamespace:isReservedNamespace}=require("./lib/settings.js"),sessionStore=require("./lib/sync/sessions.js"),memoryQueue=require("./lib/sync/memory-queue.js"),persistGate=require("./lib/sync/persist-gate.js"),avatarStore=require("./lib/avatar/store.js"),windowState=require("./lib/window-state.js"),deepLink=require("./lib/deep-link.js"),quickLauncherLib=require("./lib/quick-launcher.js");let foreignMemory;try{foreignMemory=require("../client/foreign-memory.js")}catch{foreignMemory=require("./vendor/foreign-memory.js")}const localTools=require("./lib/local/tools.js"),queueModule=require("./lib/local/queue.js"),autonomousModule=require("./lib/local/autonomous.js"),{autoContinuePlan:autoContinuePlan,autoContinueLimit:autoContinueLimit,autoRoundsDefault:autoRoundsDefault}=require("./lib/local/autonomous.js"),entitlementModule=require("./lib/local/entitlement.js"),telemetryModule=require("./lib/local/telemetry.js"),covenantModule=require("./lib/local/covenant.js"),{createTelemetry:createTelemetry,telemetryEnabled:telemetryEnabled}=telemetryModule,IPC_PREFIX="aegis:",MODEL_PREFIX="model:",SYNC_PREFIX="sync:",TOOLS_PREFIX="tools:",QUICK_PREFIX="quick:",QUEUE_PREFIX="queue:",AUTO_PREFIX="auto:",DESKTOP_CLASSES=Object.freeze(["aegis","byok","local"]),CHAT_DELTA_CHANNEL=`${IPC_PREFIX}chatDelta`,MENU_NEW_CHAT_CHANNEL=`${IPC_PREFIX}menuNewChat`,MENU_SEARCH_CHANNEL=`${IPC_PREFIX}menuSearch`,MENU_EXPORT_MARKDOWN_CHANNEL=`${IPC_PREFIX}menuExportMarkdown`,MENU_EXPORT_JSON_CHANNEL=`${IPC_PREFIX}menuExportJson`,MENU_FINGERPRINT_CHANNEL=`${IPC_PREFIX}menuFingerprint`,MENU_GOOGLE_DRIVE_CHANNEL=`${IPC_PREFIX}menuGoogleDrive`,DEEP_LINK_CHANNEL=`${IPC_PREFIX}deepLink`,QUICK_LAUNCHER_PUSH_CHANNEL=`${IPC_PREFIX}quickLauncherPush`,QUEUE_PROGRESS_CHANNEL=`${QUEUE_PREFIX}progress`,QUEUE_MAX_TASK_CHARS=8e3,QUEUE_MAX_ROUNDS=200,QUEUE_MAX_WORKERS=8,QUEUE_EFFORTS=new Set(["low","medium","high"]);function taggedChunk(e,t){return{...e&&"object"==typeof e?e:{delta:e},id:t}}const APP_VERSION=require("./package.json").version;function maskKey(e){return e?e.length<=10?"configured":`${e.slice(0,9)}…${e.slice(-4)}`:null}function upgradeInfo(e){const t=e&&e.status,n=e&&e.data||{},r="string"==typeof n.error?n.error:"";if(402!==t&&"free_session_limit_reached"!==r)return null;const o=null!=n.tokensUsed?n.tokensUsed:null!=n.sessionsUsed?n.sessionsUsed:null,s=null!=n.tokenLimit?n.tokenLimit:null!=n.freeSessionLimit?n.freeSessionLimit:null;return{url:n.upgradeUrl||"https://aegiscloud.org/go/upgrade?s=desktop&c=status_card",used:o,limit:s,code:r||"free_session_limit_reached"}}function errorText(e){return e&&e.message?e.message:String(e)}function isAbortShapedError(e){return!(!e||"object"!=typeof e||!0!==e.aegisCancelled&&"AbortError"!==e.name&&"ABORT_ERR"!==e.code)}function abortedTurnPayload(e){return{aborted:!0,status:0,code:"ABORT_ERR",message:errorText(e),choices:[{message:{content:""}}]}}function describeSyncError(e){const t=e&&(e.status||e.response&&e.response.status)||0,n=errorText(e);return upgradeInfo(e)?{kind:"quota",status:t||402,message:n,hint:"the plan's synced-token ceiling is reached — free space in the account dashboard or upgrade to keep syncing"}:401===t?{kind:"auth",status:t,message:n,hint:"the memory token was refused — re-enter your AEGIS API key to exchange a new one"}:{kind:"error",status:t||null,message:n,hint:null}}function syncErrorReason(e){return e?e.hint?`${e.message} — ${e.hint}`:e.message:"sync failed"}async function billingResult(e){try{const t=await e();return{ok:!0,url:t&&t.url||null,status:0,reason:null,setupRequired:!1,upgrade:null}}catch(e){const t=e&&e.data||{};return{ok:!1,url:null,status:e&&e.status||0,reason:errorText(e),setupRequired:Boolean(t.setup_required),upgrade:upgradeInfo(e)}}}const{bankAmount:bankAmount,parseTopupAmount:parseTopupAmount,startTopup:startTopup,createCreditWatch:createCreditWatch,TOPUP_POLL_MS:TOPUP_POLL_MS,TOPUP_POLL_TRIES:TOPUP_POLL_TRIES}=sharedTopup;let topupWatch=null;function watchTopupCredit(e,t){const n=t||{},r=n.intervalMs||TOPUP_POLL_MS,o=n.log;topupWatch&&clearInterval(topupWatch);const s=createCreditWatch(e,n.maxTries?{maxTries:n.maxTries}:void 0),a=()=>{topupWatch&&clearInterval(topupWatch),topupWatch=null,s.stop()},i=async()=>{const e=await s.tick();"credited"===e.state?(a(),(e=>{if("function"!=typeof n.notify)try{const t=electron&&electron.Notification;t&&t.isSupported()&&new t({title:"AEGIS Desktop",body:`Bank credited — €${e.toFixed(2)} available`}).show()}catch{}else n.notify(e)})(e.amount)):"expired"===e.state&&(a(),o&&o("top-up: no credit observed within the watch window; stopping"))};return topupWatch=setInterval(i,r),topupWatch&&"function"==typeof topupWatch.unref&&topupWatch.unref(),{stop:a,tick:i,get baseline(){return s.baseline}}}async function saveMemoryWithQueue(e,t,n,r){const o=avatarStore.normalizeMemoryEntry(n);try{const t=await e.memorySave(o);return r&&o&&"object"==typeof o&&r.awardSave(o,{session:o.session}),t}catch(e){const s=upgradeInfo(e);if(s)return{ok:!1,queued:0,saved:0,upgrade:s,reason:errorText(e)};if(!t||!n)throw e;return memoryQueue.enqueue(t,o),r&&o&&"object"==typeof o&&r.awardQueued(o,{session:o.session}),{ok:!0,queued:!0,reason:errorText(e)}}}async function normalizeMemoryRead(e){try{const t=await e,n=quotaFromPayload(t);return n?Object.assign({},t,{upgrade:n}):t}catch(e){const t=upgradeInfo(e);if(!t)throw e;return{entries:[],upgrade:t}}}function quotaFromPayload(e){if(!e||"object"!=typeof e)return null;const t=null!=e.tokensUsed?e.tokensUsed:null,n=null!=e.tokenLimit?e.tokenLimit:null;return null==t||null==n||n<=0||t<n?null:{url:"https://aegiscloud.org/go/upgrade?s=desktop&c=memory_quota",used:t,limit:n,code:"sync_quota_reached"}}async function importForeignMemory(e,t,n,r){const o=n||{},s=foreignMemory.scan({sources:o.sources,limit:o.limit||1e3}),a=foreignMemory.describe(s),i=s.sources.map((e=>({id:e.id,label:e.label,verified:e.verified,present:e.present,count:e.count,skipped:e.skipped,files:e.files}))),c={summary:a,totals:s.totals,sources:i};if(!o.confirm||!s.entries.length)return{...c,ok:!0,dryRun:!o.confirm,saved:0,queued:0};let u=0,l=0;const d=[];let p=null;for(const n of foreignMemory.chunk(s.entries,200))try{const t=await e.memorySaveBatch(n);if(u+=t&&t.saved||n.length,r&&n.length){const e=n[0]||{};r.awardImports(n,{source:e.session||e.source||"foreign-import"})}}catch(e){if(p=upgradeInfo(e),!p&&t)for(const e of n)memoryQueue.enqueue(t,e),l+=1,r&&r.awardQueued(e,{session:e&&e.session});d.push(errorText(e));break}return{...c,ok:0===d.length,dryRun:!1,saved:u,queued:l,upgrade:p,reason:d[0]||null}}function resolveIconsDir(e,t,n){return e?path.join(t,"icons"):path.join(n,"build")}function iconForPlatform(e,t){return"darwin"===t?path.join(e,"icon.icns"):"win32"===t?path.join(e,"icon.ico"):path.join(e,"icon.png")}function isSafeExternalUrl(e){if("string"!=typeof e||!e)return!1;try{const t=new URL(e);return"http:"===t.protocol||"https:"===t.protocol}catch{return!1}}function providerRouteConfigured(e){try{const t=e&&e.settings&&e.settings.list;return"function"==typeof t&&(t.call(e.settings)||[]).some((e=>{if(!e||!e.provider||isReservedNamespace(e.provider))return!1;const t="string"==typeof e.baseURL?e.baseURL.trim():"";return Boolean(e.configured||t)}))}catch{return!1}}function createIpcDispatch(e,t,n,r,o,s,a){let i=null;const c=new Proxy({},{get(e,n){i||(i=createFingerprintService({dir:t,getVaultBackend:a}));const r=i[n];return"function"==typeof r?r.bind(i):r},has:(e,n)=>(i||(i=createFingerprintService({dir:t,getVaultBackend:a})),n in i)}),u=()=>{try{return Boolean("function"==typeof o&&o())}catch{return!1}},l=r||(()=>Promise.reject(new Error("no opener configured")));return{status:()=>({appVersion:APP_VERSION,clientVersion:e.clientVersion,apiBase:e.apiBase,keyConfigured:Boolean(e.apiKey),keyMask:maskKey(e.apiKey),providerConfigured:u()}),setApiKey:t=>{try{const r=t&&t.key;return e.setApiKey(r||""),n&&n(e.apiKey),{ok:!0,keyConfigured:Boolean(e.apiKey),keyMask:maskKey(e.apiKey)}}catch(e){return{ok:!1,error:e&&e.message||String(e)}}},verifyApiKey:async()=>{try{return{ok:!0,...await e.verifyApiKey()}}catch(e){return{ok:!1,error:e&&e.message||String(e)}}},tokenBankBalance:()=>e.tokenBankBalance(),billingCheckout:()=>billingResult((()=>e.billingCheckout())),tokenBankTopup:async t=>{const n=parseTopupAmount(t&&t.amountEur);if(!n.ok)return{ok:!1,url:null,status:400,reason:n.message,setupRequired:!1,upgrade:null};const r=await startTopup(e,n.amount);return!0===r.ok&&r.url&&watchTopupCredit(e),{ok:!0===r.ok,url:r.url,status:r.status,reason:r.ok?null:r.hint?`${r.message} — ${r.hint}`:r.message,setupRequired:r.setupRequired,upgrade:null}},listModels:()=>e.listModels(),chatCompletion:t=>e.chatCompletion({prompt:t&&t.prompt,system:t&&t.system,model:t&&t.model,mode:t&&t.mode,maxTokens:t&&t.maxTokens,stream:t&&t.stream,onStream:t&&t.onStream}),fingerprintStatus:()=>c.status(),fingerprintKeygen:e=>c.keygen(e||{}),fingerprintMint:e=>c.mint(e||{}),fingerprintVerify:e=>c.verify(e||{}),fingerprintBackup:e=>c.backup(e||{})
+// gdrive:AEGIS-AGPL/records and writes the `.anchor.json` link beside the
+,fingerprintPublish:e=>c.publish(e||{}),fingerprintAnchor:e=>c.anchor(e||{}),fingerprintVault:()=>c.vaultList(),fingerprintVaultAudit:()=>c.vaultAudit(),byokStatus:()=>e.byokStatus(),byokSet:t=>e.byokSet(t&&t.provider,t&&t.apiKey),memorySearch:t=>normalizeMemoryRead(e.memorySearch(t&&t.query,t&&t.limit)),memorySave:n=>saveMemoryWithQueue(e,t,n&&n.entry,s),memoryList:t=>normalizeMemoryRead(e.memoryList(t&&t.limit)),verifyToken:t=>e.verifyToken(t&&t.token),memoryActivate:t=>e.memoryActivate(t&&t.token),memoryPull:t=>e.memoryPull(t&&t.since),memorySaveBatch:t=>e.memorySaveBatch(t&&t.entries),memoryImport:n=>importForeignMemory(e,t,n,s),importConversation:t=>e.importConversation(t||{}),openExternal:e=>{const t=e&&e.url;return isSafeExternalUrl(t)?Promise.resolve(l(t)).then((()=>({ok:!0})),(e=>({ok:!1,reason:errorText(e)}))):Promise.resolve({ok:!1,reason:"unsupported URL scheme"})}}}function withReplyNotify(e,t,n){return n?e.then((e=>(n(t,e),e))):e}function registerIpc(e,t,n,r,o,s,a,i){const c=createIpcDispatch(t,n,r,o,a,void 0,i);for(const[t,n]of Object.entries(c))"chatCompletion"!==t?e.handle(`${IPC_PREFIX}${t}`,((e,t)=>n(t))):e.handle(`${IPC_PREFIX}${t}`,((e,t)=>{const r={...t||{}};if(!r.stream)return withReplyNotify(n(r),e,s);const o=e&&e.sender;return withReplyNotify(n({...r,stream:!0,onStream:e=>{o&&"function"==typeof o.send&&!o.isDestroyed()&&o.send(CHAT_DELTA_CHANNEL,taggedChunk(e,r.sessionId))}}),e,s)}));return c}function createConfirmModeDispatch(e){if(!e)throw new Error("createConfirmModeDispatch requires a settings store");return{getConfirmMode:()=>({enabled:e.getConfirmMode()}),setConfirmMode:t=>{const n=t&&t.enabled;return"boolean"!=typeof n?{enabled:e.getConfirmMode()}:{enabled:e.setConfirmMode(n)}}}}function withAutoRoundsSwitch(e,t){const n=e.setConfirmMode;return{...e,setConfirmMode:e=>{const r=n(e);return e&&"boolean"==typeof e.enabled&&t&&"function"==typeof t.setAutoRounds&&t.setAutoRounds(!1===e.enabled),r}}}function registerConfirmModeIpc(e,t){for(const[n,r]of Object.entries(t))e.handle(`${IPC_PREFIX}${n}`,((e,t)=>r(t)));return t}function createVaultBackendDispatch(e){if(!e)throw new Error("createVaultBackendDispatch requires a settings store");return{getVaultBackend:()=>e.vaultBackendConfig(),setVaultBackend:t=>e.setVaultBackendConfig(t&&t.backend)}}function createTelemetryDispatch(e){const t=e||null;return{telemetryEvent:e=>{try{if(!t||"function"!=typeof t.record)return{ok:!1,reason:"telemetry off"};const n=e&&"object"==typeof e?e:{};return t.record(n.event,{campaign:n.campaign,surface:n.surface})?{ok:!0}:{ok:!1,reason:"not an allowlisted funnel event"}}catch(e){return{ok:!1,reason:errorText(e)}}},telemetryReport:()=>{try{return t&&"function"==typeof t.report?t.report():{enabled:!1,transport:"off"}}catch(e){return{enabled:!1,error:errorText(e)}}}}}function createCovenantDispatch(e){return{covenantStatus:()=>({ok:!0,covenant:e.snapshot(),gapReport:e.gapReport()}),covenantGapReport:()=>({ok:!0,gapReport:e.gapReport()})}}function registerCovenantIpc(e,t){for(const[n,r]of Object.entries(t))e.handle(`${IPC_PREFIX}${n}`,((e,t)=>r(t)));return t}function registerTelemetryIpc(e,t){for(const[n,r]of Object.entries(t))e.handle(`${IPC_PREFIX}${n}`,((e,t)=>r(t)));return t}function safeExportBasename(e){return(e&&(e.title||e.id)||"session").replace(/[^\w.-]+/g,"_").slice(0,80)||"session"}function createExportDispatch(e,t,n,r){return{exportSession:async o=>{const s=o&&o.sessionId,a=o&&"json"===o.format?"json":"markdown",i=s?e.getSession(t,s):null;if(!i)return{ok:!1,reason:"session not found"};const c="json"===a?e.toJson(i):e.toMarkdown(i),u="json"===a?"json":"md",l="json"===a?[{name:"JSON",extensions:["json"]}]:[{name:"Markdown",extensions:["md"]}],d=await n({defaultPath:`${safeExportBasename(i)}.${u}`,filters:l});if(!d||d.canceled||!d.filePath)return{ok:!1,canceled:!0};try{await r(d.filePath,c)}catch(e){return{ok:!1,reason:errorText(e)}}return{ok:!0,filePath:d.filePath}}}}function registerExportIpc(e,t,n,r,o){const s=createExportDispatch(t,n,r,o);for(const[t,n]of Object.entries(s))e.handle(`${IPC_PREFIX}${t}`,((e,t)=>n(t)));return s}function createQuickLauncherDispatch(e,t={}){const n=Boolean(t.isPackaged),r=t.applyConfig||(()=>({active:!1,reason:null})),o=t.pushToMain||(()=>({ok:!1,reason:"no main window"}));let s={active:!1,reason:null};return{status:function(){return{...e.quickLauncherConfig(),packaged:n,...s}},setConfig:function(t){const o=e.setQuickLauncherConfig({enabled:t&&t.enabled,shortcut:t&&t.shortcut});return s=r(o)||{active:!1,reason:null},{...o,packaged:n,...s}},pushToMain:(e,t)=>o(e,t)}}function registerQuickLauncherIpc(e,t){for(const[n,r]of Object.entries(t))"pushToMain"!==n?e.handle(`${QUICK_PREFIX}${n}`,((e,t)=>r(t))):e.handle(`${QUICK_PREFIX}${n}`,((e,t)=>r(t,e)));return t}function resolveUserDataDir(e){if(e&&"function"==typeof e.getPath)try{return e.getPath("userData")}catch{}return path.join(os.homedir(),".aegiscode")}function createEngine(e,{app:t,safeStorage:n,dir:r,sessionsDir:o}={}){const s=r||resolveUserDataDir(t),a=createSettingsStore({dir:s,safeStorage:n});return a.migrateLegacyAegisKey(),{engine:createLocalEngine({aegis:e,settings:a}),sessionsDir:o||sessionStore.resolveStoreDir(s),settingsDir:s,settings:a}}const PREVIEW_READ_MAX_BYTES=524288;function readTextFileForPreview(e){try{const t=e&&"string"==typeof e.file?e.file:"",n=e&&"string"==typeof e.cwd?e.cwd:"";if(!t||!n||!path.isAbsolute(n))return null;const r=fs.realpathSync(n),o=fs.realpathSync(path.resolve(r,t)),s=path.relative(r,o);if(""===s||s.startsWith("..")||path.isAbsolute(s))return null;const a=fs.statSync(o);if(!a.isFile())return null;if(a.size<=PREVIEW_READ_MAX_BYTES)return{text:fs.readFileSync(o,"utf8"),truncated:!1};const i=fs.openSync(o,"r");try{const e=Buffer.alloc(PREVIEW_READ_MAX_BYTES),t=fs.readSync(i,e,0,PREVIEW_READ_MAX_BYTES,0);let n=e.toString("utf8",0,t);const r=n.lastIndexOf("\n");return r>0&&(n=n.slice(0,r+1)),{text:n,truncated:!0}}finally{fs.closeSync(i)}}catch{return null}}function createModelDispatch(e,{env:t=process.env,settings:n}={}){const r=new Map;let o,s=autoRoundsDefault(t),a=!1;const i=()=>{const t=n||e&&e.settings||null,r=e=>"boolean"==typeof e?e:void 0;let i;try{if(t&&"function"==typeof t.confirmModeState){const e=t.confirmModeState();i=r(e&&e.enabled)}void 0===i&&t&&"function"==typeof t.getConfirmMode&&(i=r(t.getConfirmMode()))}catch{}return a||void 0===i||(void 0===o?o=i:i!==o&&(a=!0,s=!0)),!(!s||!t||void 0===i)&&!1===i},c={listClasses:async()=>(await e.listClasses()).filter((e=>DESKTOP_CLASSES.includes(e.class))),listModels:t=>e.listModels(t&&t.class),chat:n=>{const o=n&&n.onStream;if("function"!=typeof o)return e.chat(n,o);const s=n&&n.sessionId||"";return e.chat(n,(n=>{if(n&&n.rounds&&n.rounds.id&&i()){const a=autoContinuePlan({on:!0,used:r.get(s)||0,limit:autoContinueLimit(t)});if(r.set(s,a.used),a.auto){const t="function"==typeof e.respondRoundsAsk?e.respondRoundsAsk(n.rounds.id,!0):{ok:!1};if(t&&t.ok){const e=Number(n.rounds.spent)||0;return void o({note:`auto mode: the ${e}-round limit was reached — continuing automatically (${a.used}/${a.cap}, then it asks).`})}}}o(n)}))},"settings.get":()=>e.settings.list().filter((e=>!(e&&isReservedNamespace(e.provider)))),"settings.set":t=>e.settings.set(t&&t.provider,{baseURL:t&&t.baseURL,key:t&&t.key}),"settings.remove":t=>e.settings.remove(t&&t.provider),"userModels.get":()=>e.userModels(),"userModels.add":t=>e.addUserModel(t&&t.provider,t&&t.model),"userModels.remove":t=>e.removeUserModel(t&&t.provider,t&&t.model),"userModels.discover":t=>e.discoverModels(t&&t.provider),"userModels.addAll":t=>e.addUserModels(t&&t.provider,t&&t.ids),"userModels.canDiscover":t=>Boolean(e.canDiscoverModels(t&&t.provider)),"userModels.discoverable":()=>e.discoverableProviders(),"memoryPersist.get":()=>e.settings.memoryPersistState(),"memoryPersist.set":t=>e.settings.setMemoryPersist(Boolean(t&&t.enabled)),cancel:t=>e.cancel(t&&t.sessionId),respondApproval:t=>e.respondApproval(t&&t.approvalId,t&&t.decision),respondRoundsAsk:t=>"function"==typeof e.respondRoundsAsk?e.respondRoundsAsk(t&&t.roundsAskId,t&&t.decision):{ok:!1},clearApprovals:t=>e.clearSessionApprovals(t&&t.sessionId)};return Object.defineProperties(c,{autoRoundsOn:{value:i,enumerable:!1},setAutoRounds:{value:e=>{s=Boolean(e),a=!0},enumerable:!1}}),c}function createSyncDispatch(e,t,n,r){let o=null;function s(){return Boolean(n&&n.apiKey)}async function a(){const r=e.listPending(t);if(!s())return{ok:!1,queued:r.length,reason:"no AEGIS key configured"};const a=await async function(){const e=memoryQueue.listQueued(t);if(!e.length)return{flushed:0,remaining:0,upgrade:null};const r=[];let o=0,s=null;for(let t=0;t<e.length;t+=1)try{await n.memorySave(e[t]),o+=1}catch(n){const o=upgradeInfo(n);if(o){s=o,r.push(...e.slice(t));break}r.push(e[t])}return memoryQueue.save(t,r),{flushed:o,remaining:r.length,upgrade:s}}();if(!r.length)return{ok:!0,queued:0,pushed:0,memoryFlushed:a.flushed,upgrade:a.upgrade};let i=0,c=null,u=null;for(const o of r)try{const r=await n.conversationSyncPush({session_id:o.id,title:o.title,messages:o.messages}),s=r&&(r.session_id||r.id);e.markSynced(t,o.id,{remoteId:s}),i+=1}catch(e){if(c=e,u=describeSyncError(e),"quota"===u.kind||"auth"===u.kind)break}const l=e.listPending(t).length;i&&(o=Date.now());const d=(c?upgradeInfo(c):null)||a.upgrade;return 0===i&&c?{ok:!1,queued:l,reason:syncErrorReason(u),failed:u?[u]:[],kind:u?u.kind:"error",status:u?u.status:0,hint:u?u.hint:null,memoryFlushed:a.flushed,upgrade:d}:{ok:!0,queued:l,pushed:i,failed:u?[u]:[],memoryFlushed:a.flushed,upgrade:d}}const i=persistGate.createAutoPush({push:a,dir:r||t});return{auto:()=>i.auto(),memoryPersistState:()=>i.gate(),listSessions:()=>({sessions:e.listSessions(t)}),open:n=>e.getSession(t,n&&n.sessionId),save:n=>e.upsertSession(t,n||{}),append:n=>e.appendMessage(t,n&&n.sessionId,n&&n.message),delete:n=>e.deleteSession(t,n&&n.sessionId),push:a,pull:async function(){if(!s())return{ok:!1,merged:0,reason:"no AEGIS key configured"};try{const r=await n.conversationSyncPull(),s=e.mergeRemoteSessions(t,r&&r.sessions||[]);return o=Date.now(),{ok:!0,merged:s,failed:[],upgrade:null}}catch(e){const t=describeSyncError(e);return{ok:!1,merged:0,reason:syncErrorReason(t),failed:[t],kind:t.kind,status:t.status,hint:t.hint,upgrade:upgradeInfo(e)}}},status:()=>({count:e.listSessions(t).length,pending:e.listPending(t).length,cloud:s(),lastSyncAt:o})}}const HEARTBEAT_RETRY_BASE_MS=5e3,HEARTBEAT_RETRY_MAX_MS=3e4;function createHeartbeatRetry(e,t={}){const n="function"==typeof t.now?t.now:()=>Date.now(),r=Number(t.baseMs)>0?Number(t.baseMs):HEARTBEAT_RETRY_BASE_MS,o=Number(t.maxMs)>0?Number(t.maxMs):HEARTBEAT_RETRY_MAX_MS;let s=0,a=0,i=null,c=!1;function u(e){s+=1;const t=Math.min(o,r*2**Math.max(0,s-1));return i=e||"push failed",a=n()+t,{attempted:!0,ok:!1,error:i,failures:s,retryInMs:t}}return{run:async function(){const t=n();if(s>0&&t<a)return{attempted:!1,ok:!1,error:i,failures:s,retryInMs:a-t};if(c)return{attempted:!1,ok:!1,error:i,failures:s,retryInMs:0};c=!0;try{const t=await e();return t&&!1===t.ok?u(t.reason||t.kind||"push failed"):(s=0,a=0,i=null,{attempted:!0,ok:!0,error:null,failures:0,retryInMs:0,result:t})}catch(e){return u(errorText(e))}finally{c=!1}},state:function(){const e=n();return{failures:s,lastError:i,retryInMs:s>0&&a>e?a-e:0}},recordFailure:e=>u(errorText(e))}}function registerModelIpc(e,t,n,r,o,s,a){const i=createModelDispatch(t),c=createSyncDispatch(sessionStore,n,r,a),u=createHeartbeatRetry((()=>c.push()),s);function l(){const e=u.run();e&&"function"==typeof e.catch&&e.catch((e=>u.recordFailure(e)))}for(const[t,n]of Object.entries(i))"chat"!==t?"listModels"!==t?e.handle(`${MODEL_PREFIX}${t}`,((e,t)=>n(t))):e.handle(`${MODEL_PREFIX}${t}`,((e,t)=>(l(),n(t)))):e.handle(`${MODEL_PREFIX}${t}`,((e,t)=>{const r={...t||{}},s=!0===r.bestEffort;delete r.bestEffort;const a="low"===r.effort||"medium"===r.effort?r.effort:"high";r.effort=a;const i=e&&e.sender,c=r.class||"model",u=n({...r,onStream:e=>{i&&"function"==typeof i.send&&!i.isDestroyed()&&i.send(CHAT_DELTA_CHANNEL,taggedChunk(e,r.sessionId))}});return s?u.then((t=>(o&&o(e,t),t)),(e=>{const t=e&&"number"==typeof e.status?e.status:0,n=e&&e.code||"";return console.warn(`[model] background ${c} turn produced no answer: ${errorText(e)}${t?` (status ${t})`:""}${n?` [${n}]`:""}`),{bestEffortFailed:!0,status:t,code:n||void 0,message:errorText(e),choices:[{message:{content:""}}]}})):withReplyNotify(u,e,o).catch((e=>{if(!isAbortShapedError(e))throw e;return console.warn(`[model] ${c} turn stopped before it finished: ${errorText(e)} [ABORT_ERR]`),abortedTurnPayload(e)}))}));e.on(`${MODEL_PREFIX}readTextFile`,((e,t)=>{e.returnValue=readTextFileForPreview(t)}));for(const[t,n]of Object.entries(c))"status"!==t?e.handle(`${SYNC_PREFIX}${t}`,((e,t)=>n(t))):e.handle(`${SYNC_PREFIX}${t}`,((e,t)=>{l();const r=n(t);return r&&"object"==typeof r?{...r,retry:u.state()}:r}));return{modelDispatch:i,syncDispatch:c,heartbeat:u}}function createQueueEngine(e,t){return createLocalEngine({aegis:e,settings:t,getConfirmMode:()=>!1})}function queueEngineWithDeniedApprovals(e){return e&&"function"==typeof e.chat?{...e,chat:(t,n)=>e.chat(t,(t=>{(t=>{const n=t&&t.approval;if(n&&n.id&&"function"==typeof e.respondApproval)try{e.respondApproval(n.id,"deny")}catch{}})(t),(t=>{const n=t&&t.rounds;if(n&&n.id&&"function"==typeof e.respondRoundsAsk)try{e.respondRoundsAsk(n.id,!1)}catch{}})(t),"function"==typeof n&&n(t)}))}:e}function isExistingDir(e){try{return fs.statSync(e).isDirectory()}catch{return!1}}function clampInt(e,t,n){const r=Number(e);return!Number.isInteger(r)||r<t||r>n?null:r}function createQueueDispatch({engine:e,env:t=process.env,queue:n=queueModule,autonomous:r=autonomousModule,entitlement:o=entitlementModule.createEntitlement({}),log:s=(()=>{})}={}){if(!e||"function"!=typeof e.chat)throw new Error("createQueueDispatch: a local engine with chat() is required");let a=null,i=!1,c=!1;const u=r.createQueueWorker({engine:queueEngineWithDeniedApprovals(e),env:t,log:e=>{e&&"start"===e.type&&(a=e.taskId),e&&"finish"===e.type&&(a=null),s(e)},canFanOut:()=>o.current().entitled});function l(){const e=n.loadQueue(t);return{ok:!0,items:e,pending:n.pendingCount(e),running:e.find((e=>e&&"running"===e.status))||null,draining:c,stopping:i,defaultCwd:process.cwd(),defaultModel:r.resolveModel({env:t}),queueFile:n.queuePath(t),runs:n.readRuns(t,{limit:20}),entitlement:o.current()}}const d=e=>(e||[]).map((e=>({id:e.id,ok:Boolean(e.ok),error:e.error||null})));return{enqueue:async e=>{await o.refresh();const s=o.gateFanout({workers:clampInt(e&&e.workers,1,QUEUE_MAX_WORKERS),fanout:Boolean(e&&!0===e.fanout)});if(!s.ok)return{...s,...l()};const{opts:a,error:i}=function(e){const t=e||{},n=String(null==t.task?"":t.task).trim();if(!n)return{error:"a queued task needs text"};if(n.length>QUEUE_MAX_TASK_CHARS)return{error:`task text is too long (${n.length} > ${QUEUE_MAX_TASK_CHARS} chars)`};const o=String(null==t.cwd?"":t.cwd).trim()||process.cwd();if(!path.isAbsolute(o))return{error:"the working directory must be an absolute path"};if(!isExistingDir(o))return{error:`not a directory: ${o}`};const s=r.normalizeClass(t.class),a=String(null==t.model?"":t.model).trim().slice(0,120)||null,i=r.modelRefusal(a,s);if(i)return{error:i};const c=String(null==t.effort?"":t.effort).trim().toLowerCase();return{opts:{task:n,cwd:o,class:s,model:a,effort:QUEUE_EFFORTS.has(c)?c:null,workers:clampInt(t.workers,1,QUEUE_MAX_WORKERS),maxRounds:clampInt(t.maxRounds,1,QUEUE_MAX_ROUNDS),singlePass:!(!0===t.fanout||!0===t.autonomous),commit:Boolean(t.commit),source:"desktop"}}}(e);return i?{ok:!1,reason:i,...l()}:{ok:!0,item:n.addTask(t,a),...l()}},list:()=>l(),entitlement:async e=>(await o.refresh({force:Boolean(e&&!0===e.force)}),{ok:!0,...l()}),clear:e=>({...n.clearQueue(t,{all:Boolean(e&&e.all)}),ok:!0,...l()}),retry:e=>{const r=e&&e.id,o=n.retryTask(t,r);return o?{ok:!0,item:o,...l()}:{ok:!1,reason:`no task #${r}`,...l()}},remove:e=>{const r=e&&e.id,o=n.loadQueue(t),s=n.findTask(o,r);return s?"running"===s.status?{ok:!1,reason:`task #${s.id} is running — stop the drain first`,...l()}:(n.saveQueue(t,o.filter((e=>Number(e&&e.id)!==Number(s.id)))),{ok:!0,removed:s.id,...l()}):{ok:!1,reason:`no task #${r}`,...l()}},drain:()=>async function(){if(c)return{ok:!1,reason:"a drain is already running in this window",...l()};let e;c=!0,i=!1;try{const t=await u.proceed({max:1});e=t.locked?{ok:!1,locked:!0,holder:t.holder,ran:[]}:{ok:!0,ran:d(t.ran)}}catch(t){e={ok:!1,reason:errorText(t),ran:[]}}return c=!1,a=null,{...e,...l()}}(),proceed:()=>async function(){if(c)return{ok:!1,reason:"a drain is already running in this window",...l()};c=!0,i=!1;const e=[];let t;try{for(;;){const n=await u.proceed({max:1});if(n.locked){t={ok:!1,locked:!0,holder:n.holder,ran:d(e)};break}if(!n.ran.length){t={ok:!0,stopped:i,ran:d(e)};break}if(e.push(...n.ran),i){t={ok:!0,stopped:!0,ran:d(e)};break}}}catch(n){t={ok:!1,reason:errorText(n),ran:d(e)}}return c=!1,a=null,{...t,...l()}}(),stop:e=>{i=!0;const t=e&&null!=e.id?e.id:a,n=null==t?null:u.cancel(t);return{ok:!0,wasDraining:c,cancelled:n,...l()}}}}function createAutoDispatch({autoDrain:e,autoMint:t}={}){if(!e||"function"!=typeof e.state)throw new Error("createAutoDispatch: the auto-drain automation is required");if(!t||"function"!=typeof t.state)throw new Error("createAutoDispatch: the auto-mint automation is required");return{autoStatus:()=>({ok:!0,drain:e.state(),mint:t.state()}),autoSetDrain:t=>{const n=t||{},r={};null!=n.enabled&&(r.enabled=Boolean(n.enabled)),null!=n.intervalMs&&(r.intervalMs=Number(n.intervalMs));try{return{ok:!0,drain:e.set(r)}}catch(e){return{ok:!1,error:errorText(e)}}},autoSetMint:e=>{const n=e||{},r={};null!=n.enabled&&(r.enabled=Boolean(n.enabled)),null!=n.publish&&(r.publish=Boolean(n.publish));try{return{ok:!0,mint:t.set(r)}}catch(e){return{ok:!1,error:errorText(e)}}},autoSealNow:async e=>{const n=e||{};null!=n.publish&&t.set({publish:Boolean(n.publish)});try{const e=await t.flush();return t.reset(),{ok:!0,...e}}catch(e){return t.reset(),{ok:!1,error:errorText(e)}}}}}function registerQueueIpc(e,{engine:t,env:n,queue:r,autonomous:o,entitlement:s,aegis:a}={}){let i=null;const c=createQueueDispatch({engine:t,env:n,queue:r,autonomous:o,entitlement:s||entitlementModule.createEntitlement({probe:a&&"function"==typeof a.verifyApiKey?async()=>{const e=await a.verifyApiKey(),t=e&&"object"==typeof e?{...e}:{};if("function"==typeof a.tokenBankBalance)try{const e=await a.tokenBankBalance();e&&"object"==typeof e&&(null!=e.balance_micros?t.balance_micros=e.balance_micros:null!=e.balance_eur&&(t.balance_eur=e.balance_eur))}catch{}return t}:void 0}),log:e=>{i&&"function"==typeof i.send&&("function"==typeof i.isDestroyed&&i.isDestroyed()||i.send(QUEUE_PROGRESS_CHANNEL,e))}});for(const[t,n]of Object.entries(c))e.handle(`${QUEUE_PREFIX}${t}`,((e,t)=>(i=e&&e.sender||null,n(t))));return c}function registerAutoIpc(e,t){for(const[n,r]of Object.entries(t))e.handle(`${AUTO_PREFIX}${n}`,((e,t)=>r(t)));return t}const UPDATE_STATUS_CHANNEL=`${IPC_PREFIX}updateStatus`,ACCOUNT_STATUS_CHANNEL=`${IPC_PREFIX}accountStatusChanged`,UPDATE_CHECK_INTERVAL_MS=144e5,UPDATE_RETRY_BACKOFF_MS=[6e4,3e5,9e5,36e5];function describeRegistryFailure(e,t,n){switch(e){case"not-found":return`${n} is not published on the npm registry (404)`;case"forbidden":return`the npm registry refused the request (${t||"auth"})`;case"malformed":return"the npm registry sent a response this app could not read";case"too-large":return"the npm registry response was too large to read";case"timeout":return"the npm registry did not respond in time";case"network":return"the npm registry could not be reached";default:return"the update check did not complete"}}function createNpmUpdateManager({onStatus:e,packaged:t=!1,now:n=(()=>Date.now()),fetchImpl:r,setTimeoutImpl:o=setTimeout,clearTimeoutImpl:s=clearTimeout,runUpgrade:a,relaunch:i}={}){const c="aegis-desktop";let u="unknown";try{u=require("./package.json").version}catch{}let l={status:"idle",version:null,error:null,channel:"npm",reason:null,transient:!1,attempts:0,retryInMs:0,command:null,plan:null,method:null,canDownload:!1};const d=t=>(l={...l,...t},e&&e(l),l);let p=null;try{p=require("../client/update.js")}catch{try{p=require("./vendor/update.js")}catch{p=null}}let f=0,g=0,h=null,m=null,y=null,E=null;function k(){h&&s(h),h=null}async function _({announce:e=!1}={}){if(!p)return d({status:"disabled",error:"update checker unavailable"});if(m)return m;m=(async()=>{const s=l.status,a=l.version;let i;d({status:"checking",error:null,reason:null,transient:!1});try{i=await async function(){if(r)return r({pkg:c});if(p&&"function"==typeof p.checkPublished){const e=await p.checkPublished({current:u,pkg:c,now:n(),intervalMs:0});return e?{ok:e.ok,latest:e.latest,reason:e.reason,status:e.status}:{ok:!1,latest:null,reason:"unknown",status:null}}return{ok:!1,latest:null,reason:"unavailable",status:null}}()}catch(e){i={ok:!1,latest:null,reason:"unknown",status:null,error:errorText(e)}}if(i.ok){if(f=0,g=0,k(),!p.isNewer(i.latest,u))return d({status:"up-to-date",version:i.latest,error:null,reason:null,transient:!1,attempts:0,retryInMs:0});const e=function(){if(E)return E;const e=p&&p.detectInstallMethod;if("function"!=typeof e)return E="npm",E;try{E=e({env:process.env,argv:process.argv,pkg:c,entry:__dirname,fileExists:e=>fs.existsSync(path.resolve(__dirname,"..",e))})}catch{E="npm"}return E}(),n="function"==typeof p.updatePlan?p.updatePlan({current:u,latest:i.latest,behind:!0,channel:"npm",pkg:c,method:e}):null;return d({status:"available",version:i.latest,error:null,reason:null,transient:!1,attempts:0,retryInMs:0,plan:n,method:e,command:t?`${i.latest} is published — reinstall AEGIS Desktop from the installer to pick it up`:n&&n.instruction||`npm i -g ${c}@latest`,commandIsSentence:t||Boolean(n&&!n.apply),canDownload:Boolean(n&&n.apply)&&!t})}f+=1;const m=i.error||describeRegistryFailure(i.reason,i.status,c);return y=i.reason,v=i.status,("function"==typeof p.isTransientReason?p.isTransientReason(y,v):"unknown"===y)?(function(){k();const e=UPDATE_RETRY_BACKOFF_MS[Math.min(Math.max(f-1,0),UPDATE_RETRY_BACKOFF_MS.length-1)];g=n()+e,h=o((()=>{h=null,_().catch((()=>{}))}),e),h&&h.unref&&h.unref(),d({retryInMs:e})}(),d(e?{status:"error",error:m,reason:i.reason,transient:!0,attempts:f}:{status:"available"===s?"available":"unavailable",version:a,error:m,reason:i.reason,transient:!0,attempts:f})):(k(),g=0,d({status:"error",error:m,reason:i.reason,transient:!1,attempts:f,retryInMs:0}));var y,v})();try{return await m}finally{m=null}}return{status:()=>l,check:_,download:async()=>{const e=!t&&l.plan&&l.plan.apply;if(!e)return d({status:"available"===l.status?"available":l.status,command:l.plan&&l.plan.instruction||l.command,canDownload:!1});d({status:"downloading",error:null,progress:0});const n=await function(e){const t=a||((e,t)=>new Promise((n=>{execFile(e,t,{timeout:18e4,windowsHide:!0},((e,t,r)=>{if(e)return n({ok:!1,output:String(r||t||e.message||e)});n({ok:!0,output:String(t||"")})}))}))),n=!a&&p&&"function"==typeof p.installSpawn?p.installSpawn(e,{env:process.env}):null,r=n?n.command:e.command,o=n?n.args:e.args;return Promise.resolve(t(r,o)).then((e=>({ok:Boolean(e&&e.ok),output:String(e&&e.output||"")})),(e=>({ok:!1,output:errorText(e)})))}(e);return n.ok?d({status:"downloaded",version:l.version,error:null,progress:100,command:`npm i -g ${c}@latest`,canDownload:!1}):d({status:"error",transient:!1,error:n.output.trim().split("\n").slice(-3).join(" ").trim()||"the installer failed",command:`${e.command} ${e.args.join(" ")}`})},quitAndInstall:()=>{"downloaded"===l.status&&(i||(()=>{try{const{app:e}=require("electron");e.relaunch(),e.exit(0)}catch{}}))()},start:()=>{_().catch((()=>{})),y=setInterval((()=>_().catch((()=>{}))),UPDATE_CHECK_INTERVAL_MS),y.unref&&y.unref()},stop:()=>{k(),y&&clearInterval(y),y=null},retryState:()=>({attempts:f,retryAt:g,inFlight:!!m,hasTimer:!!h})}}function createUpdateManager({isPackaged:e,onStatus:t}){let n={status:"idle",version:null,error:null,canDownload:!1};return createNpmUpdateManager({onStatus:function(e){n={...n,...e},t&&t(n)},packaged:Boolean(e)})}function createUpdateDispatch(e){return{checkForUpdates:()=>e.check({announce:!0}),downloadUpdate:()=>e.download(),quitAndInstallUpdate:()=>(e.quitAndInstall(),{ok:!0}),updateStatus:()=>Promise.resolve(e.status())}}function registerUpdateIpc(e,t){const n=createUpdateDispatch(t);for(const[t,r]of Object.entries(n))e.handle(`${IPC_PREFIX}${t}`,((e,t)=>r(t)));return n}function sendToFocusedWindow(e,t){const n=e.getFocusedWindow()||e.getAllWindows()[0];n&&!n.isDestroyed()&&n.webContents.send(t)}function sendDeepLinkToWindow(e,t){if(!e||e.isDestroyed()||!t)return;const n=()=>{e.isDestroyed()||e.webContents.send(DEEP_LINK_CHANNEL,t)};e.webContents.isLoadingMainFrame()?e.webContents.once("did-finish-load",n):n()}function buildAppMenu({app:e,Menu:t,BrowserWindow:n,updateManager:r,loggedIn:o}){const s="darwin"===process.platform;e.setAboutPanelOptions({applicationName:e.getName(),applicationVersion:e.getVersion(),version:e.getVersion()});const a={label:"Check for Updates…",click:()=>r.check({announce:!0})},i={label:"New Chat",accelerator:"CmdOrCtrl+N",click:()=>sendToFocusedWindow(n,MENU_NEW_CHAT_CHANNEL)},c={label:"Search…",accelerator:"CmdOrCtrl+K",click:()=>sendToFocusedWindow(n,MENU_SEARCH_CHANNEL)},u={label:"Save as…",accelerator:"CmdOrCtrl+S",click:()=>sendToFocusedWindow(n,MENU_EXPORT_MARKDOWN_CHANNEL)},l={label:"Export Session…",click:()=>sendToFocusedWindow(n,MENU_EXPORT_JSON_CHANNEL)},d={label:"Authorship Panel…",click:()=>sendToFocusedWindow(n,MENU_FINGERPRINT_CHANNEL)},p={label:"Google Drive Backup…",enabled:Boolean(o),click:()=>sendToFocusedWindow(n,MENU_GOOGLE_DRIVE_CHANNEL)},f=[...s?[{label:e.getName(),submenu:[{role:"about"},a,{type:"separator"},{role:"services"},{type:"separator"},{role:"hide"},{role:"hideOthers"},{role:"unhide"},{type:"separator"},{role:"quit"}]}]:[],{label:"File",submenu:[i,{type:"separator"},u,l,{type:"separator"},...s?[]:[a,{type:"separator"}],s?{role:"close"}:{role:"quit"}]},{label:"Edit",submenu:[{role:"undo"},{role:"redo"},{type:"separator"},{role:"cut"},{role:"copy"},{role:"paste"},{role:"selectAll"}]},{label:"View",submenu:[c,{type:"separator"},d,p,{type:"separator"},{role:"reload",accelerator:"CmdOrCtrl+R"},{role:"forceReload"},{type:"separator"},{role:"toggleDevTools",accelerator:"CmdOrCtrl+Shift+I"}]},...s?[]:[{label:"Help",submenu:[{role:"about"}]}]];return t.buildFromTemplate(f)}function bootstrap(){const{app:e,BrowserWindow:t,ipcMain:n,safeStorage:r,shell:o,Menu:s,Notification:a,screen:i,dialog:c,globalShortcut:u}=electron;if(e.disableHardwareAcceleration(),e.commandLine.appendSwitch("disable-gpu"),e.commandLine.appendSwitch("disable-software-rasterizer"),e.commandLine.appendSwitch("disable-gpu-compositing"),e.commandLine.appendSwitch("disable-features","UsePortalAccentColor"),process.argv.some((e=>/^--(log-level|enable-logging)/.test(e)))||process.env.ELECTRON_ENABLE_LOGGING||e.commandLine.appendSwitch("log-level","3"),!e.requestSingleInstanceLock())return void e.quit();if(e.setName("AEGIS Desktop"),envFile&&"function"==typeof envFile.loadEnvFile)try{const e=envFile.loadEnvFile();e.loose&&console.warn(`aegis: ${e.file} is readable by other accounts (mode ${e.mode.toString(8)}) — consider \`chmod 600\` on it.`)}catch(e){console.warn(`aegis: could not read ${envFile.envFileFor()}: ${e&&e.message}`)}e.setAsDefaultProtocolClient(deepLink.PROTOCOL);let l=deepLink.parseDeepLinkArgv(process.argv);e.on("open-url",((e,n)=>{e.preventDefault();const r=deepLink.parseDeepLinkUrl(n);if(!r)return;const o=t.getFocusedWindow()||t.getAllWindows()[0];o?sendDeepLinkToWindow(o,r):l=r}));const d=createClient(credentials.clientOptions()),p=resolveUserDataDir(e),{engine:f,sessionsDir:g,settingsDir:h,settings:m}=createEngine(d,{app:e,safeStorage:r,dir:p}),y=createAccountKey({aegis:d,credentials:credentials,persistKey:e=>m.setAegisKey(e),provision:(e,t)=>autoProvision.autoProvisionApiKey(e,t,{app:"desktop"}),describeFailure:autoProvision.provisionFailureText,onChange:e=>U(e)}),E=createGoogleConnect({aegis:d,credentials:credentials,persistKey:e=>m.setAegisKey(e),openUrl:e=>!!isSafeExternalUrl(e)&&(o.openExternal(e),!0),googleSignIn:googleSignIn,driveConnect:driveConnectLib,driveUpload:driveUploadLib,onAccountChange:()=>U(y.status())}),k=Boolean(d.apiKey),_=autoProvision.autoProvisionApiKey(d,credentials,{app:"desktop"}).then((e=>{if(y.recordStartup(e),!e.key&&!d.apiKey){const t=e.error&&(e.error.status||e.error.message||String(e.error))||"no key returned";console.warn(`auto-provision: no account key from register-device (${t})`)}return e}));try{const{wrapProviderKeyMirror:e}=require("./lib/provider-key-mirror.js"),t=e=>console.warn(`aegis: ${e}`);e(m,envFile,{onWarn:t}),f&&f.settings&&f.settings!==m&&e(f.settings,envFile,{onWarn:t})}catch(e){console.warn(`aegis: could not wire the shared env-file key mirror: ${e&&e.message}`)}let v=null;const A=(e,n)=>{!function(e){const n=e&&e.sender,r=n&&t.fromWebContents(n);if(!r||r.isDestroyed())return;if(r.isFocused()&&r.isVisible())return;if(!a||!a.isSupported())return;const o=new a({title:"AEGIS Desktop",body:"Reply ready"});o.on("click",(()=>{r.isDestroyed()||(r.isMinimized()&&r.restore(),r.isVisible()||r.show(),r.focus())})),o.show()}(e),v&&"function"==typeof v.note&&v.note({sessionId:n&&n.sessionId||null})};registerIpc(n,d,p,(e=>{const t=m.setAegisKey(e);return e?credentials.saveApiKey(e):credentials.clearApiKey(),t}),(e=>o.openExternal(e)),A,(()=>providerRouteConfigured(f)),(()=>m.vaultBackendConfig().backend));const b=registerModelIpc(n,f,g,d,A,void 0,h);registerConfirmModeIpc(n,withAutoRoundsSwitch(createConfirmModeDispatch(m),b.modelDispatch)),registerConfirmModeIpc(n,createVaultBackendDispatch(m)),registerTelemetryIpc(n,createTelemetryDispatch(createTelemetry({dir:h,enabled:telemetryEnabled(process.env,m),appVersion:(()=>{try{return"function"==typeof e.getVersion?e.getVersion():""}catch{return""}})()}))),registerCovenantIpc(n,createCovenantDispatch(covenantModule));const S=registerQueueIpc(n,{engine:createQueueEngine(d,m),aegis:d}),C=createAutoDrain({proceed:()=>S.proceed(),settings:m,queue:queueModule,env:process.env,log:e=>{e&&"skip"!==e.type&&console.log("[auto-drain]",e.type,e.reason||e.error||"")}});let R=null;v=createAutoMint({mint:e=>(R||(R=createFingerprintService({dir:p,getVaultBackend:()=>m.vaultBackendConfig().backend})),R.mint(e||{})),settings:m}),registerAutoIpc(n,createAutoDispatch({autoDrain:C,autoMint:v})),C.start(),v.start();let w=null,I=null;function P(){const n=(I&&!I.isDestroyed()||(I=new t({width:560,height:320,show:!1,frame:!1,alwaysOnTop:!0,skipTaskbar:!0,resizable:!1,movable:!0,fullscreenable:!1,minimizable:!1,maximizable:!1,backgroundColor:"#0d1117",icon:iconForPlatform(resolveIconsDir(e.isPackaged,process.resourcesPath,__dirname),process.platform),webPreferences:{preload:path.join(__dirname,"preload.js"),contextIsolation:!0,nodeIntegration:!1,sandbox:!0}}),I.setMenuBarVisibility(!1),I.loadFile(path.join(__dirname,"renderer","quick.html")),I.webContents.on("before-input-event",((e,t)=>{"keyDown"!==t.type||"Escape"!==t.key||I.isDestroyed()||I.hide()})),I.on("blur",(()=>{!I.isDestroyed()&&I.isVisible()&&I.hide()})),I.on("closed",(()=>{I=null}))),I);if(n.isVisible())return void n.hide();const r=i.getCursorScreenPoint(),o=i.getAllDisplays(),s=n.getBounds(),a=quickLauncherLib.computeQuickLauncherBounds({cursor:r,displays:o,size:{width:s.width,height:s.height}});n.setBounds(a),n.show(),n.focus()}const M=createQuickLauncherDispatch(m,{isPackaged:e.isPackaged,applyConfig:function(t){if(u.unregisterAll(),!quickLauncherLib.shouldEnableGlobalShortcut({isPackaged:e.isPackaged,enabled:t.enabled}))return{active:!1,reason:null};try{if(!u.register(t.shortcut,P)){const e=`"${t.shortcut}" could not be registered — it may already be in use by another application.`;return console.warn(`[quick-launcher] ${e}`),{active:!1,reason:e}}return{active:!0,reason:null}}catch(e){const n=errorText(e);return console.warn(`[quick-launcher] failed to register shortcut "${t.shortcut}": ${n}`),{active:!1,reason:n}}},pushToMain:function(e,n){const r=n&&n.sender&&t.fromWebContents(n.sender);r&&!r.isDestroyed()&&r.hide();const o=w&&!w.isDestroyed()?w:t.getAllWindows().find((e=>e!==r))||null;return o?(o.webContents.send(QUICK_LAUNCHER_PUSH_CHANNEL,e||{}),o.isMinimized()&&o.restore(),o.isVisible()||o.show(),o.focus(),{ok:!0}):{ok:!1,reason:"no main window is open"}}});registerQuickLauncherIpc(n,M);let T=null;e.on("will-quit",(()=>{T&&"function"==typeof T.stop&&T.stop(),u.unregisterAll(),F&&"function"==typeof F.stop&&F.stop()}));let N=!1;e.on("before-quit",(t=>{!N&&f&&"function"==typeof f.unloadLocalModels&&(t.preventDefault(),Promise.resolve().then((()=>f.unloadLocalModels())).catch((()=>{})).finally((()=>{N=!0,e.quit()})))}));const D=new Set;function U(e){for(const t of D)t.isDestroyed()||t.webContents.send(ACCOUNT_STATUS_CHANNEL,e);L()}function L(){s.setApplicationMenu(buildAppMenu({app:e,Menu:s,BrowserWindow:t,updateManager:F,loggedIn:Boolean(d.apiKey)}))}const F=createUpdateManager({isPackaged:e.isPackaged,onStatus:function(e){for(const t of D)t.isDestroyed()||t.webContents.send(UPDATE_STATUS_CHANNEL,e)}});registerUpdateIpc(n,F),n.handle(`${IPC_PREFIX}accountStatus`,(()=>y.status())),n.handle(`${IPC_PREFIX}registerAccount`,(()=>y.registerAccount())),n.handle(`${IPC_PREFIX}driveSignIn`,(()=>E.signInWithGoogle())),n.handle(`${IPC_PREFIX}driveConnect`,(()=>E.connectDrive())),n.handle(`${IPC_PREFIX}driveStatus`,(()=>E.status())),n.handle(`${IPC_PREFIX}driveSyncMemory`,(()=>E.syncMemoryNow())),registerExportIpc(n,sessionStore,g,(e=>c.showSaveDialog(t.getFocusedWindow(),e)),((e,t)=>fs.promises.writeFile(e,t,"utf8"))),L();const q=pathToFileURL(path.join(__dirname,"renderer","index.html")).href;function O(){const n=windowState.load(p),r=windowState.clampToDisplay(n,i.getAllDisplays(),{width:1080,height:720}),s=resolveIconsDir(e.isPackaged,process.resourcesPath,__dirname),a=new t({...r,minWidth:720,minHeight:480,backgroundColor:"#0d1117",title:"AEGIS Desktop",icon:iconForPlatform(s,process.platform),webPreferences:{preload:path.join(__dirname,"preload.js"),contextIsolation:!0,nodeIntegration:!1,sandbox:!0,spellcheck:!0}});n&&n.isMaximized&&a.maximize(),a.webContents.setWindowOpenHandler((({url:e})=>(isSafeExternalUrl(e)&&o.openExternal(e),{action:"deny"}))),a.webContents.on("will-navigate",((e,t)=>{t!==q&&(e.preventDefault(),isSafeExternalUrl(t)&&o.openExternal(t))}));let c=null;function u(){if(a.isDestroyed())return;const e=a.isMaximized(),t=e?a.getNormalBounds():a.getBounds();windowState.save(p,{...t,isMaximized:e})}function l(){c&&clearTimeout(c),c=setTimeout(u,500)}return a.on("resize",l),a.on("move",l),a.on("close",(()=>{c&&clearTimeout(c),u()})),a.loadFile(path.join(__dirname,"renderer","index.html")),D.add(a),w=a,a.on("closed",(()=>{D.delete(a),w===a&&(w=null)})),a}e.whenReady().then((async()=>{if(!credentials.normalizeApiKey(process.env[credentials.KEY_ENV])){const e=await _,t=startupKeyOverride({mintedKey:k?"":e.key,hostKey:credentials.normalizeApiKey(m.aegisRawKey())});if(t)credentials.saveApiKey(t),d.setApiKey(t);else{const e=credentials.preferNewest(m.aegisRawKey(),m.aegisKeySavedAt());e.key&&(d.setApiKey(e.key),"shared"===e.source&&m.setAegisKey(e.key))}}try{T&&"function"==typeof T.stop&&T.stop(),T=sharedPresence.createPresence({apiKey:d.apiKey,app:"desktop",version:e.getVersion(),platform:process.platform,install:sharedFingerprint.machineFingerprint(),queueDepth:()=>{try{return queueModule.readQueue(queueModule.queuePath()).filter((e=>e&&"pending"===e.status)).length}catch{return 0}},autonomous:!1,log:(e,t)=>{"debug"!==e&&console.warn(t)}}),T.start()}catch(e){console.warn("presence: beacon not started",e&&e.message)}try{const{backfillProviderKeys:e}=require("./lib/provider-key-mirror.js"),t=e=>console.warn(`aegis: ${e}`),n=e(m,envFile,{onWarn:t});n.mirrored.length&&console.warn(`aegis: shared ${n.mirrored.join(", ")} key(s) with the other hosts (${envFile.envFileFor()})`),f&&f.settings&&f.settings!==m&&e(f.settings,envFile,{onWarn:t})}catch(e){console.warn(`aegis: could not backfill the shared env-file key mirror: ${e&&e.message}`)}M.setConfig(m.quickLauncherConfig());const t=O();F.start(),l&&sendDeepLinkToWindow(t,l)})),e.on("window-all-closed",(()=>{"darwin"!==process.platform&&e.quit()})),e.on("activate",(()=>{0===t.getAllWindows().length&&O()})),e.on("second-instance",((e,n)=>{const r=t.getAllWindows()[0],o=deepLink.parseDeepLinkArgv(n);if(r)r.isMinimized()&&r.restore(),r.isVisible()||r.show(),r.focus(),o&&sendDeepLinkToWindow(r,o);else{const e=O();o&&sendDeepLinkToWindow(e,o)}}))}electron&&electron.app&&bootstrap(),module.exports={createIpcDispatch:createIpcDispatch,registerIpc:registerIpc,providerRouteConfigured:providerRouteConfigured,IPC_PREFIX:IPC_PREFIX,MODEL_PREFIX:MODEL_PREFIX,SYNC_PREFIX:SYNC_PREFIX,watchTopupCredit:watchTopupCredit,bankAmount:bankAmount,TOPUP_POLL_MS:TOPUP_POLL_MS,TOPUP_POLL_TRIES:TOPUP_POLL_TRIES,CHAT_DELTA_CHANNEL:CHAT_DELTA_CHANNEL,MENU_NEW_CHAT_CHANNEL:MENU_NEW_CHAT_CHANNEL,MENU_SEARCH_CHANNEL:MENU_SEARCH_CHANNEL,MENU_EXPORT_MARKDOWN_CHANNEL:MENU_EXPORT_MARKDOWN_CHANNEL,MENU_EXPORT_JSON_CHANNEL:MENU_EXPORT_JSON_CHANNEL,MENU_FINGERPRINT_CHANNEL:MENU_FINGERPRINT_CHANNEL,MENU_GOOGLE_DRIVE_CHANNEL:MENU_GOOGLE_DRIVE_CHANNEL,DEEP_LINK_CHANNEL:DEEP_LINK_CHANNEL,UPDATE_STATUS_CHANNEL:UPDATE_STATUS_CHANNEL,UPDATE_CHECK_INTERVAL_MS:UPDATE_CHECK_INTERVAL_MS,taggedChunk:taggedChunk,maskKey:maskKey,createModelDispatch:createModelDispatch,DESKTOP_CLASSES:DESKTOP_CLASSES,readTextFileForPreview:readTextFileForPreview,PREVIEW_READ_MAX_BYTES:PREVIEW_READ_MAX_BYTES,createSyncDispatch:createSyncDispatch,registerModelIpc:registerModelIpc,createHeartbeatRetry:createHeartbeatRetry,describeSyncError:describeSyncError,HEARTBEAT_RETRY_BASE_MS:HEARTBEAT_RETRY_BASE_MS,HEARTBEAT_RETRY_MAX_MS:HEARTBEAT_RETRY_MAX_MS,createEngine:createEngine,resolveUserDataDir:resolveUserDataDir,importForeignMemory:importForeignMemory,isSafeExternalUrl:isSafeExternalUrl,createUpdateManager:createUpdateManager,createNpmUpdateManager:createNpmUpdateManager,createUpdateDispatch:createUpdateDispatch,describeRegistryFailure:describeRegistryFailure,UPDATE_RETRY_BACKOFF_MS:UPDATE_RETRY_BACKOFF_MS,registerUpdateIpc:registerUpdateIpc,buildAppMenu:buildAppMenu,createExportDispatch:createExportDispatch,registerExportIpc:registerExportIpc,safeExportBasename:safeExportBasename,sendDeepLinkToWindow:sendDeepLinkToWindow,QUICK_PREFIX:QUICK_PREFIX,QUICK_LAUNCHER_PUSH_CHANNEL:QUICK_LAUNCHER_PUSH_CHANNEL,createQuickLauncherDispatch:createQuickLauncherDispatch,registerQuickLauncherIpc:registerQuickLauncherIpc,createConfirmModeDispatch:createConfirmModeDispatch,createVaultBackendDispatch:createVaultBackendDispatch,withAutoRoundsSwitch:withAutoRoundsSwitch,createTelemetryDispatch:createTelemetryDispatch,registerTelemetryIpc:registerTelemetryIpc,createCovenantDispatch:createCovenantDispatch,registerCovenantIpc:registerCovenantIpc,registerConfirmModeIpc:registerConfirmModeIpc,QUEUE_PREFIX:QUEUE_PREFIX,QUEUE_PROGRESS_CHANNEL:QUEUE_PROGRESS_CHANNEL,QUEUE_MAX_TASK_CHARS:QUEUE_MAX_TASK_CHARS,QUEUE_MAX_ROUNDS:QUEUE_MAX_ROUNDS,createQueueEngine:createQueueEngine,queueEngineWithDeniedApprovals:queueEngineWithDeniedApprovals,createQueueDispatch:createQueueDispatch,registerQueueIpc:registerQueueIpc,AUTO_PREFIX:AUTO_PREFIX,createAutoDispatch:createAutoDispatch,registerAutoIpc:registerAutoIpc};