clauderipple 0.11.1 → 0.12.1

package/dist/app/dist/main.js

@@ -17,6 +17,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const claude_desktop_1 = require("./claude-desktop");
+const update_model_1 = require("./update-model");
 const protocol_1 = require("./protocol");
 const status_model_1 = require("./status-model");
 const window_1 = require("./window");
@@ -100,6 +101,8 @@ const STRINGS = {
         updateNow: "Update",
         later: "Later",
         updating: (v) => `Updating to ClaudeRipple ${v}…`,
+        autoUpdated: (v) => `Updated to ClaudeRipple ${v}`,
+        autoAvailable: (v) => `New version ${v} — click to update`,
         updateDone: (v) => `Updated to ClaudeRipple ${v}`,
         updateFailed: "The update did not finish",
         updateCheckFailed: "Could not check for updates",
@@ -182,6 +185,8 @@ const STRINGS = {
         updateNow: "업데이트",
         later: "나중에",
         updating: (v) => `ClaudeRipple ${v} 업데이트 중…`,
+        autoUpdated: (v) => `ClaudeRipple ${v}로 업데이트됨`,
+        autoAvailable: (v) => `새 버전 ${v} — 클릭해서 업데이트`,
         updateDone: (v) => `ClaudeRipple ${v} 업데이트 완료`,
         updateFailed: "업데이트를 완료하지 못했습니다",
         updateCheckFailed: "업데이트 정보를 확인하지 못했습니다",
@@ -264,6 +269,8 @@ const STRINGS = {
         updateNow: "更新",
         later: "稍后",
         updating: (v) => `正在更新到 ClaudeRipple ${v}…`,
+        autoUpdated: (v) => `已更新到 ClaudeRipple ${v}`,
+        autoAvailable: (v) => `新版本 ${v} — 点击更新`,
         updateDone: (v) => `已更新到 ClaudeRipple ${v}`,
         updateFailed: "更新未完成",
         updateCheckFailed: "无法检查更新",
@@ -346,6 +353,8 @@ const STRINGS = {
         updateNow: "アップデート",
         later: "後で",
         updating: (v) => `ClaudeRipple ${v} にアップデート中…`,
+        autoUpdated: (v) => `ClaudeRipple ${v} にアップデートしました`,
+        autoAvailable: (v) => `新バージョン ${v} — クリックして更新`,
         updateDone: (v) => `ClaudeRipple ${v} にアップデートしました`,
         updateFailed: "アップデートが完了しませんでした",
         updateCheckFailed: "アップデートを確認できませんでした",
@@ -428,6 +437,8 @@ const STRINGS = {
         updateNow: "Actualizar",
         later: "Más tarde",
         updating: (v) => `Actualizando a ClaudeRipple ${v}…`,
+        autoUpdated: (v) => `Actualizado a ClaudeRipple ${v}`,
+        autoAvailable: (v) => `Nueva versión ${v} — haz clic para actualizar`,
         updateDone: (v) => `Actualizado a ClaudeRipple ${v}`,
         updateFailed: "La actualización no se completó",
         updateCheckFailed: "No se pudo comprobar si hay actualizaciones",
@@ -510,6 +521,8 @@ const STRINGS = {
         updateNow: "Atualizar",
         later: "Depois",
         updating: (v) => `Atualizando para o ClaudeRipple ${v}…`,
+        autoUpdated: (v) => `Atualizado para o ClaudeRipple ${v}`,
+        autoAvailable: (v) => `Nova versão ${v} — clique para atualizar`,
         updateDone: (v) => `Atualizado para o ClaudeRipple ${v}`,
         updateFailed: "A atualização não foi concluída",
         updateCheckFailed: "Não foi possível verificar atualizações",
@@ -621,6 +634,7 @@ async function poll() {
         downSince = null;
         downNotified = false;
         answered = true;
+        void handleRouterUpdate(last).catch((error) => console.error(`update notification: ${error}`));
         void reconcileRouter(last);
     }
     catch (e) {
@@ -632,7 +646,7 @@ async function poll() {
         // the outage the notification is for. Neither is the direct mode, where the router being off
         // is the point — so doctor is asked first, and once per outage. With the window on screen the
         // user is already looking at the same news.
-        if ((0, status_model_1.shouldNotifyDown)({ downForMs: Date.now() - downSince, graceMs: DOWN_NOTIFY_AFTER_MS, alreadyNotified: downNotified, updating, busy: !!rec.busy || (0, window_1.windowVisible)(), mode: rec.doctor?.mode ?? null })) {
+        if ((0, status_model_1.shouldNotifyDown)({ downForMs: Date.now() - downSince, graceMs: DOWN_NOTIFY_AFTER_MS, alreadyNotified: downNotified, updating: updating || Date.now() < routerUpdateUntil, busy: !!rec.busy || (0, window_1.windowVisible)(), mode: rec.doctor?.mode ?? null })) {
             downNotified = true;
             void refreshDoctor().then(() => {
                 if (!last && rec.doctor?.mode !== "direct")
@@ -643,6 +657,12 @@ async function poll() {
     // Up or down changed: what doctor said about the rest (direct, mixed) may have changed with it.
     if (before !== null && before !== answered && !rec.busy)
         void refreshDoctor();
+    // Claude quit or reopened by hand has applied the change as surely as the button would.
+    if (rec.restartClaude && !rec.busy && Date.now() - restartCheckedAt >= RESTART_CHECK_MS) {
+        restartCheckedAt = Date.now();
+        if (!(0, status_model_1.restartStillOwed)(restartOwedSince, await (0, claude_desktop_1.claudeStartedAt)()))
+            rec.restartClaude = false;
+    }
     render();
 }
 // Held so the handlers are not collected with it before the user gets to the notification.
@@ -856,6 +876,11 @@ const rec = {
     result: null,
     restartClaude: false,
 };
+/** When the connection last changed in a way Claude only picks up on its next start. */
+let restartOwedSince = 0;
+let restartCheckedAt = 0;
+/** How often a pending "reopen Claude" step asks whether Claude was reopened some other way. */
+const RESTART_CHECK_MS = 15_000;
 let doctorRun = null;
 /** One `doctor` at a time; callers that arrive while one runs share it. */
 function refreshDoctor() {
@@ -985,8 +1010,11 @@ async function runAction(action, args) {
         ? (0, status_model_1.repairDetails)(out, r.output)
         : [out?.detail ?? "", ...(ok ? [] : (0, status_model_1.tailLines)(out ? "" : r.output, 8))].filter(Boolean);
     rec.result = { action, ok, timedOut: r.timedOut, details, at: Date.now() };
-    if (ok && out?.restartClaude)
-        rec.restartClaude = true;
+    if (ok && out?.restartClaude) {
+        // A Claude that is not running picks the change up when it next starts: nothing to ask for.
+        restartOwedSince = Date.now();
+        rec.restartClaude = (0, status_model_1.restartStillOwed)(restartOwedSince - 1, await (0, claude_desktop_1.claudeStartedAt)());
+    }
     if (out?.doctor) {
         rec.doctor = out.doctor;
         rec.doctorFailed = false;
@@ -1025,6 +1053,83 @@ async function restartClaude() {
 let availableUpdate = null;
 let updating = false;
 const UPDATE_CHECK_MS = 12 * 60 * 60 * 1000;
+let routerUpdateUntil = 0;
+let updateNotification = null;
+let updateSeen;
+const updateSeenFile = node_path_1.default.join(home, "update-notifications.json");
+function loadUpdateSeen() {
+    try {
+        return (0, update_model_1.readUpdateSeen)(JSON.parse(node_fs_1.default.readFileSync(updateSeenFile, "utf8")));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            console.error(`update notification state: ${error}`);
+        return { updated: [], available: [] };
+    }
+}
+async function relaunchTray() {
+    electron_1.app.releaseSingleInstanceLock();
+    const result = await runCliResult(["tray"]);
+    if (!result.ok) {
+        // Keep a functioning tray if its replacement could not start.
+        if (!electron_1.app.requestSingleInstanceLock())
+            electron_1.app.quit();
+        throw new Error(result.output || "could not relaunch tray");
+    }
+    electron_1.app.quit();
+}
+async function handleRouterUpdate(status) {
+    if (status.autoUpdate?.running)
+        routerUpdateUntil = Date.now() + 10 * 60_000;
+    else
+        routerUpdateUntil = 0;
+    if (updating)
+        return;
+    updateSeen ??= loadUpdateSeen();
+    const notice = (0, update_model_1.updateNotice)(status.version, electron_1.app.getVersion(), status.autoUpdate, updateSeen);
+    if (!notice)
+        return;
+    // Memory dedup is immediate; disk dedup must succeed before a relaunch to avoid restart loops.
+    updateSeen = (0, update_model_1.rememberUpdate)(updateSeen, notice);
+    node_fs_1.default.mkdirSync(home, { recursive: true });
+    const tmp = `${updateSeenFile}.${process.pid}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(tmp, JSON.stringify(updateSeen) + "\n", { mode: 0o600 });
+        node_fs_1.default.renameSync(tmp, updateSeenFile);
+    }
+    finally {
+        try {
+            node_fs_1.default.unlinkSync(tmp);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    if (notice.kind === "available") {
+        const check = { current: status.version, latest: notice.version, newer: true, kind: status.autoUpdate?.kind ?? "unknown" };
+        availableUpdate = check;
+        if (electron_1.Notification.isSupported()) {
+            updateNotification = new electron_1.Notification({ title: "ClaudeRipple", body: L.autoAvailable(notice.version), icon: notifyIcon() });
+            updateNotification.on("click", () => { void offerUpdate(check).catch((error) => console.error(`offer update: ${error}`)); });
+            updateNotification.show();
+        }
+        return;
+    }
+    if (electron_1.Notification.isSupported()) {
+        updateNotification = new electron_1.Notification({ title: "ClaudeRipple", body: L.autoUpdated(notice.version), icon: notifyIcon() });
+        updateNotification.show();
+    }
+    if (notice.relaunch) {
+        updating = true;
+        try {
+            await relaunchTray();
+        }
+        finally {
+            updating = false;
+        }
+    }
+}
 async function checkForUpdate() {
     const r = await runCliResult(["update", "--check", "--json"]);
     try {
@@ -1068,6 +1173,23 @@ async function offerUpdate(check) {
     const version = check.latest ?? "";
     if (electron_1.Notification.isSupported())
         new electron_1.Notification({ title: "ClaudeRipple", body: L.updating(version), icon: notifyIcon() }).show();
+    if (last?.autoUpdate) {
+        // Share the router's coordinator with its scheduler instead of racing a second installer.
+        try {
+            const response = await fetch(`${adminUrl()}api/update`, { method: "POST", signal: AbortSignal.timeout(35_000) });
+            if (!response.ok)
+                throw new Error(await response.text());
+            routerUpdateUntil = Date.now() + 10 * 60_000;
+        }
+        catch (error) {
+            await electron_1.dialog.showMessageBox({ type: "warning", message: L.updateFailed, detail: String(error) });
+        }
+        finally {
+            updating = false;
+            render();
+        }
+        return; // /api/status will confirm completion, notify and relaunch this tray.
+    }
     const r = await runCliResult(["update"]);
     updating = false;
     if (!r.ok) {
@@ -1078,11 +1200,8 @@ async function offerUpdate(check) {
     availableUpdate = null;
     if (electron_1.Notification.isSupported())
         new electron_1.Notification({ title: "ClaudeRipple", body: L.updateDone(version), icon: notifyIcon() }).show();
-    // A new tray from the new files, then this one goes. The lock is let go first, or the new tray
-    // would see this one and leave.
-    electron_1.app.releaseSingleInstanceLock();
-    await runCliResult(["tray"]);
-    electron_1.app.quit();
+    // A new tray from the new files, then this one goes.
+    await relaunchTray();
 }
 // Offer setup only when there is no working installation at all. A developer who runs the router
 // from a source checkout keeps that; switching to the app's bundled runtime is a menu action.

package/dist/app/dist/status-model.js

@@ -7,6 +7,7 @@ exports.parseJsonOutput = parseJsonOutput;
 exports.tailLines = tailLines;
 exports.trayState = trayState;
 exports.shouldNotifyDown = shouldNotifyDown;
+exports.restartStillOwed = restartStillOwed;
 exports.repairDetails = repairDetails;
 exports.routeRequest = routeRequest;
 /**
@@ -54,6 +55,17 @@ function trayState(health, doctor) {
 function shouldNotifyDown(o) {
     return !o.alreadyNotified && !o.updating && !o.busy && o.downForMs >= o.graceMs && o.mode !== "direct";
 }
+/**
+ * Whether the "reopen Claude" step is still owed after a connection change at `changedAt`. Claude
+ * picks the change up on its next start, whoever restarts it: a Claude that is not running, or one
+ * that started after the change, owes nothing. Only an unknown start time keeps the step — the
+ * button used to be the only way to clear it, so reopening by hand left it on screen for good.
+ */
+function restartStillOwed(changedAt, claudeStartedAt) {
+    if (claudeStartedAt === undefined)
+        return true;
+    return claudeStartedAt !== null && claudeStartedAt <= changedAt;
+}
 /** Lines for the "Details" fold after a repair: each step as ✓/✗ with what it said. */
 function repairDetails(out, raw) {
     if (!out?.steps?.length)

package/dist/app/dist/update-model.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUpdateSeen = readUpdateSeen;
+exports.updateNotice = updateNotice;
+exports.rememberUpdate = rememberUpdate;
+function readUpdateSeen(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("invalid update notification state");
+    const s = value;
+    if (!Array.isArray(s.updated) || !Array.isArray(s.available)
+        || [...s.updated, ...s.available].some((v) => typeof v !== "string"))
+        throw new Error("invalid update notification versions");
+    return { updated: s.updated, available: s.available };
+}
+/** No I/O or Electron: only confirmed completion is a reason to replace a running tray. */
+function updateNotice(routerVersion, trayVersion, state, seen) {
+    if (!state)
+        return null;
+    if (!state.running && state.lastUpdatedTo === routerVersion && state.lastUpdatedFrom && state.lastUpdatedFrom !== routerVersion
+        && typeof state.lastUpdatedAt === "number" && Number.isFinite(state.lastUpdatedAt) && !seen.updated.includes(routerVersion)) {
+        return { kind: "updated", version: routerVersion, relaunch: trayVersion !== routerVersion && (state.kind === "script" || state.kind === "npm") };
+    }
+    const version = state.available;
+    const automatic = state.enabled !== false && (state.kind === "script" || state.kind === "npm");
+    if (version && version !== routerVersion && !state.running && !automatic && !seen.available.includes(version)) {
+        return { kind: "available", version };
+    }
+    return null;
+}
+function rememberUpdate(seen, notice) {
+    return { ...seen, [notice.kind]: [...new Set([...seen[notice.kind], notice.version])] };
+}

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.11.1",
+  "version": "0.12.1",
   "type": "commonjs"
 }

package/dist/cli/src/index.js

@@ -146,9 +146,13 @@ async function image() {
         ...(images.length ? { images } : {}),
     };
     const port = adminPort(new ConfigStore(configPath()).get());
+    // Claude Code exports its session to Bash commands; the router logs it with the image so the
+    // request list shows which session spent the subscription.
+    const session = process.env.CLAUDE_CODE_SESSION_ID;
+    const headers = { "content-type": "application/json", ...(session && /^[\w-]{1,128}$/.test(session) ? { "x-claude-code-session-id": session } : {}) };
     let res;
     try {
-        res = await fetch(`http://127.0.0.1:${port}/api/image`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+        res = await fetch(`http://127.0.0.1:${port}/api/image`, { method: "POST", headers, body: JSON.stringify(body) });
     }
     catch {
         throw new Error(`the router is not answering on 127.0.0.1:${port}; start it with: clauderipple start`);

package/dist/mod/hooks/i18n.ts

@@ -66,6 +66,7 @@ const EN = {
   'band.compact': 'Compact',
   'band.clear': 'Clear',
   'band.compactAlt': 'Compact — summarise the conversation to free context',
+  'band.compactedTimes': 'compacted {count}×',
   'band.clearAlt': 'New start (/clear) — clear the conversation and start fresh',
   'band.log': 'Log',
   'band.agents': 'Agents',
@@ -563,6 +564,7 @@ const KO: Record<Key, string> = {
   'band.compact': '압축',
   'band.clear': '새로 시작',
   'band.compactAlt': '대화 압축 — 대화를 요약해 컨텍스트를 줄입니다',
+  'band.compactedTimes': '{count}번 압축됨',
   'band.clearAlt': '새로 시작 (/clear) — 대화 내용을 비우고 새로 시작합니다',
   'band.log': '로그',
   'band.agents': '에이전트',
@@ -1058,6 +1060,7 @@ const ZH: Record<Key, string> = {
   'band.compact': '压缩',
   'band.clear': '新开',
   'band.compactAlt': '压缩对话 — 总结对话以释放上下文',
+  'band.compactedTimes': '已压缩 {count} 次',
   'band.clearAlt': '重新开始 (/clear) — 清空对话上下文，重新开始',
   'band.log': '日志',
   'band.agents': '代理',
@@ -1553,6 +1556,7 @@ const JA: Record<Key, string> = {
   'band.compact': '圧縮',
   'band.clear': '新しく開始',
   'band.compactAlt': '圧縮 — これまでの会話を要約してコンテキストを減らします',
+  'band.compactedTimes': '{count} 回圧縮済み',
   'band.clearAlt': '新しく開始 (/clear) — 会話の文脈を空にして新しく始めます',
   'band.log': 'ログ',
   'band.agents': 'エージェント',
@@ -2048,6 +2052,7 @@ const ES: Record<Key, string> = {
   'band.compact': 'Compactar',
   'band.clear': 'Reiniciar',
   'band.compactAlt': 'Compactar — resume la conversación para liberar contexto',
+  'band.compactedTimes': 'compactada {count} veces',
   'band.clearAlt': 'Empezar de nuevo (/clear) — vacía la conversación y empieza desde cero',
   'band.log': 'Registro',
   'band.agents': 'Agentes',
@@ -2543,6 +2548,7 @@ const PT: Record<Key, string> = {
   'band.compact': 'Compactar',
   'band.clear': 'Recomeçar',
   'band.compactAlt': 'Compactar — resume a conversa para liberar contexto',
+  'band.compactedTimes': 'compactada {count} vezes',
   'band.clearAlt': 'Começar de novo (/clear) — limpa a conversa e começa do zero',
   'band.log': 'Log',
   'band.agents': 'Agentes',

package/dist/mod/hooks/modes.ts

@@ -1,5 +1,6 @@
 // Operating modes in the session (docs/specs/2026-10-12-worker-tiers.md "Operating modes"): which
-// mode is on, when it ends by itself, and the eager-delegation note. Pure; register.tsx wires them.
+// mode is on, when it ends by itself, and the eager-delegation note (Base's while no mode is on).
+// Pure; register.tsx wires them.
 
 import type { Hot, LimitItem, Mode, Settings } from '../types'
 
@@ -18,21 +19,27 @@ export function modeNote(name: string): string {
   return `ClaudeRipple mode ${name}: delegate everything except judgment and final review to ripple:auto.`
 }
 
+/** What it reads while no mode is on and Base is eager. */
+const BASE_NOTE = 'ClaudeRipple: delegate everything except judgment and final review to ripple:auto.'
+
 /**
- * The eager note for this prompt: sent on the first prompt after the mode turned on, and again on
- * the first after a compaction (which clears `noted`), never on the turns between.
+ * The eager note for this prompt: Base's while no mode is on, the active mode's otherwise. Sent on
+ * the first prompt after that turned eager (a mode turning on, or Base made eager), and again on
+ * the first after a compaction (which clears `noted`), never on the turns between. When the
+ * effective delegation is not eager, nothing is said and `noted` becomes null, so making it eager
+ * again later sends the note afresh.
  */
-export function eagerNote(s: Pick<Settings, 'modes' | 'activeMode' | 'activeSince'>, noted: string | null): { note?: string; noted: string | null } {
+export function eagerNote(s: Pick<Settings, 'modes' | 'activeMode' | 'activeSince' | 'delegation'>, noted: string | null): { note?: string; noted: string | null } {
   const mode = activeModeOf(s)
-  const key = modeKey(s)
-  if (!mode || mode.delegation !== 'eager') return { noted }
-  return noted === key ? { noted } : { note: modeNote(mode.name), noted: key }
+  if ((mode?.delegation ?? s.delegation) !== 'eager') return { noted: null }
+  const key = mode ? modeKey(s) : 'base'
+  return noted === key ? { noted } : { note: mode ? modeNote(mode.name) : BASE_NOTE, noted: key }
 }
 
 /** Modes replace the base worker set, without changing fallback, allow-list or provider policy. */
 export function routingSettings(s: Settings): Settings {
   const mode = activeModeOf(s)
-  return mode ? { ...s, rules: { general: { mode: 'ladder', rungs: mode.rungs } } } : s
+  return mode ? { ...s, rules: { general: { mode: 'ladder', rungs: mode.rungs } }, domainRules: mode.domainRules } : s
 }
 
 /** The provider whose quota reset ends the mode: 'anthropic' is Claude, any other a ChatGPT provider. */

package/dist/mod/hooks/register.tsx

@@ -1,14 +1,14 @@
 // Engine wiring lives here: imported logic and drawings never receive the engine interface.
 // Timers own background work; hooks only admit/rewrite a request and record its result.
 import { atom, read, update } from 'claude-code'
-import type { AgentSpawnInput, EngineInterface, ModelCompleteResult, ModelForkResult, Register, RenderElement, RenderInput, SessionRateLimit, ToolCallInput, TurnStepInput, TurnUsage } from 'claude-code'
+import type { AgentSpawnInput, EngineInterface, ModelCompleteResult, ModelForkResult, Register, RenderElement, RenderInput, SessionCompactResult, SessionRateLimit, ToolCallInput, TurnStepInput, TurnUsage } from 'claude-code'
 import type { AgentRec, Effort, JudgeInput, JudgeKind, JudgeRun, LimitItem, ModSettingsSnapshot, Pick, Settings, StatusRequest, TierTarget, Verdict, WorkerCandidate, WorkerPick, WorkerVerdict } from '../types'
 import { MOD_SETTINGS_SCHEMA_VERSION, RUNG_EFFORT, applySettingsChanges, normalizeSettings, settingsChanges } from './settings'
 import { rungOf } from './ladder'
 import { debugText, langFrom, t } from './i18n'
 import type { Lang } from './i18n'
 import { EFFORT_JUDGE_SYSTEM, finalEffort, isCacheSafeModel, isShortFollowUp, jevEffortRequest, jevFailure, jevUsage, jevWorkerRequest, judgeContext, parseEffortVerdict, parseJevEffort, parseJevKey, parseJevWorker, shouldJudge } from './judge'
-import { AUTO_DESCRIPTION, WORKER_JUDGE_SYSTEM, agentProvider, candidateUsable, chatgptUsable, claudeCandidates, ladderOptionsFrom, ladderPick, parseWorkerVerdict, readMarker, routerModelOptions, spawnModel, spawnTitle, takesOver, TIER_MARKERS, tierOf, workerJudgeInput, zenJev } from './workers'
+import { AUTO_DESCRIPTION, WORKER_JUDGE_SYSTEM, agentProvider, candidateUsable, chatgptUsable, claudeCandidates, domainVerdict, ladderOptionsFrom, ladderPick, parseWorkerVerdict, readMarker, routerModelOptions, spawnModel, spawnTitle, takesOver, TIER_MARKERS, tierOf, workerJudgeInput, workerRule, zenJev } from './workers'
 import { MARKER, agentModel, fixSpawn } from './worker'
 import { activeModeOf, chatgptProviders, claudeWindow, eagerNote, gptLimitsFrom, modeKey, modeOver, quotaWindows, resetProvider, routingSettings } from './modes'
 import type { QuotaWindow } from './modes'
@@ -86,6 +86,8 @@ const setupStep = atom({ plugin: 'ripple', key: 'setupStep' } as const, 1)
 const compactNote = atom({ plugin: 'ripple', key: 'compactNote' } as const, '')
 const effortMenuOpen = atom({ plugin: 'ripple', key: 'effortMenuOpen' } as const, false)
 const agentsOpen = atom({ plugin: 'ripple', key: 'agentsOpen' } as const, false)
+/** Compactions of the main conversation that finished, for the Compact icon's count; /clear zeroes it. */
+const compactions = atom({ plugin: 'ripple', key: 'compactions' } as const, 0)
 const agentsShowDone = atom({ plugin: 'ripple', key: 'agentsShowDone' } as const, false)
 const agentOpen = atom({ plugin: 'ripple', key: 'agentOpen' } as const, null)
 const agentRunsOpen = atom({ plugin: 'ripple', key: 'agentRunsOpen' } as const, [])
@@ -251,6 +253,16 @@ async function installSettings($: EngineInterface, s: Settings): Promise<void> {
   if (s.keepWarm && !previous.keepWarm) await update($, warm, value => ({ ...value, stopped: undefined }))
   // Settings caught up with this chat's own choice: it follows Settings again.
   if (await read($, warmHere) === s.keepWarm) await update($, warmHere, () => null)
+  // Setup was finished (here, in another chat, or the settings came back from the router): a setup
+  // card still open is stale, and the judge's key is looked up for the source now chosen. Both
+  // survive a reload, so after a router outage they asked for setup and a Jev key again although
+  // the router held both (2026-10-20).
+  if (s.setupDone && await read($, panel) === 'setup') {
+    await update($, panel, () => null)
+    await update($, settingsDraft, () => null)
+    await update($, settingsBase, () => null)
+  }
+  if (s.judge !== previous.judge || s.jevSource !== previous.jevSource || (s.judge === 'jev' && (await read($, jev)).source === null)) await jevKey($)
 }
 function settingsSnapshot(text: string): ModSettingsSnapshot {
   const value = object(JSON.parse(text))
@@ -295,6 +307,13 @@ async function syncSettings($: EngineInterface, admin: string): Promise<void> {
     await update($, settingsBase, () => null)
   }
   if (snapshot.stored && sync.migration) sync = await update($, settingsSync, value => ({ ...value, migration: null }))
+  // A router with no settings stored (a fresh or emptied home, or a stray test router that took the
+  // live one's launchd label, 2026-10-20) is not a reset: settings this chat holds from a finished
+  // setup are kept and written back, instead of taking defaults and asking for setup again.
+  if (!snapshot.stored && !sync.migration) {
+    const held = await read($, settings)
+    if (held !== null && normalizeSettings(held).setupDone) sync = await update($, settingsSync, value => ({ ...value, migrationChecked: true, migration: normalizeSettings(held) }))
+  }
   if (!sync.migrationChecked) {
     let migration: Settings | null = null
     if (!snapshot.stored) {
@@ -703,6 +722,8 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
   let rawVerdict: WorkerVerdict | null = null
   let judgeError: string | undefined
   let target: TierTarget | undefined
+  const mode = activeModeOf(s)
+  const routing = routingSettings(s)
   if (explicit) {
     // Agent names and their file-model ids are both valid explicit routing notes.
     const name = files.has(explicit.name) ? explicit.name : [...files].find(([, f]) => agentModel(f)?.replace(/@[^@]*$/, '').toLowerCase() === explicit.name)?.[0]
@@ -710,12 +731,21 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
     verdict = { domain: 'general', level: 'standard', effort: effortOf(explicit.level) ?? 'high', why: t(language, 'toasts.explicitMarker') }
     by = 'marker'
   } else if (tier) {
-    // The main chat named the tier. The judge still rates the same brief, unawaited, so the log
-    // can later say which of the two was right (see shadowJudge).
+    // A marker owns the tier. Only a set with domain ladders needs the shadow judge's domain
+    // before dispatch; otherwise leave the existing unawaited path (and latency) unchanged.
     const named = TIER_MARKERS[tier]!
     verdict = { domain: 'general', ...named, effort: RUNG_EFFORT[rungOf(named)], why: t(language, 'toasts.sessionTier', { tier }) }
     by = 'session'
-    void shadowJudge($, s, id, { description: e.description, prompt: e.prompt })
+    const shadow = shadowJudge($, s, id, { description: e.description, prompt: e.prompt })
+    if (routing.domainRules?.ui || routing.domainRules?.backend) {
+      const judged = await shadow
+      if (judged?.verdict && 'domain' in judged.verdict) {
+        rawVerdict = judged.verdict
+        verdict.domain = judged.verdict.domain
+      }
+      ms = judged?.ms ?? 0
+      judgeError = judged?.error
+    }
   } else {
     const judged = await judge($, s, { description: e.description, prompt: e.prompt }, true)
     if (judged.verdict && 'domain' in judged.verdict) { rawVerdict = judged.verdict; verdict = judged.verdict; by = judged.by }
@@ -730,12 +760,15 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
   const providers = options && options.until > now ? Object.fromEntries(Object.entries(options.providers ?? {}).filter(([, p]) => p.exhaustedUntil === undefined || p.exhaustedUntil > now)) : {}
   const explicitCandidate = target ? pinnedCandidates.find(c => c.target.agent === target!.agent) ?? (target.agent === 'general-purpose' ? { target, model: target.model ?? 'sonnet', provider: (await read($, routerModels)).find(m => m.value.toLowerCase() === target!.model)?.provider ?? 'anthropic' } : undefined) : undefined
   if (explicitCandidate && s.providers[explicitCandidate.provider] === false) return { deny: t(language, 'workers.disabled', { provider: explicitCandidate.provider }) }
-  // An active mode moves the tiers; an explicit marker still names its own model.
-  const mode = activeModeOf(s)
-  const routing = routingSettings(s)
-  const resolved = explicitCandidate && candidateUsable(explicitCandidate, s, usable, providers)
+  // An active mode replaces the whole set; an explicit marker still names its own model. Design under
+  // the ui ladder takes the heavy level even past a tier marker: the main chat tiers by difficulty,
+  // and a design task is "standard" by that measure while its result depends on the model's taste.
+  const { rule, ladder } = workerRule(verdict.domain, routing)
+  const explicitUsable = !!explicitCandidate && candidateUsable(explicitCandidate, s, usable, providers)
+  const domained: ReturnType<typeof domainVerdict> = explicitUsable ? { verdict } : domainVerdict(verdict, rule)
+  const resolved = explicitUsable
     ? { target: target!, effort: verdict.effort }
-    : ladderPick(verdict, routing.rules.general, routing, pinnedCandidates, usable, language, routing.allow, providers, routing.allowKnown)
+    : ladderPick(domained.verdict, ladder, routing, pinnedCandidates, usable, language, routing.allow, providers, routing.allowKnown)
   const selected = resolved.target
   if (!selected) return { deny: t(language, 'workers.none') }
   const fallbackReason = resolved.fallbackReason
@@ -743,10 +776,10 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
   const model = spawnModel(selected, verdict.effort, files.has(selected.agent) ? agentModel(files.get(selected.agent)!) : undefined)
   let prompt = e.prompt
   if (marker) prompt = prompt.replace(MARKER, '').replace(/^\s*\n/, '')
-  const value: WorkerPick = { ...verdict, ...resolved, target: selected, by, ms, id, ...(fallbackReason ? { fallbackReason } : {}) }
+  const value: WorkerPick = { ...verdict, ...resolved, rule, target: selected, by, ms, id, ...(fallbackReason ? { fallbackReason } : {}) }
   // The verdict behind a pick is otherwise only in the agents panel; one debug line per pick keeps
   // it checkable: what the judge said, the rung it landed on and what ran.
-  const entry = { task: e.description.slice(0, 200), domain: value.domain, level: value.level, kind: value.kind ?? 'do', sure: value.sure, rung: value.rung, position: value.position, skipped: value.skipped, target: value.target, model: model ?? null, effort: value.effort, by, ...(mode ? { mode: mode.name } : {}), ...(fallbackReason ? { fallbackReason } : {}) }
+  const entry = { task: e.description.slice(0, 200), domain: value.domain, level: value.level, kind: value.kind ?? 'do', sure: value.sure, rule: value.rule, ...(domained.raised ? { raised: domained.raised } : {}), rung: value.rung, position: value.position, skipped: value.skipped, target: value.target, model: model ?? null, effort: value.effort, by, ...(mode ? { mode: mode.name } : {}), ...(fallbackReason ? { fallbackReason } : {}) }
   await $.ui.log('ClaudeRipple worker pick: ' + JSON.stringify(entry), { to: 'debug' })
   // The brief itself is never logged (it can hold anything); its length is. To re-judge a pick,
   // its brief is in the session's own transcript under the same description.
@@ -760,15 +793,16 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
 
 /**
  * What the judge would have said of a brief the main chat already tiered: logged beside the pick
- * (same `id`), never awaited by the spawn, never acted on. Together with each pick's outcome it is
- * what decides later whether the judge stays.
+ * (same `id`). With domain ladders the spawn awaits this same result for its domain only; without
+ * them it never waits or acts on it. The marker's tier always stands.
  */
-async function shadowJudge($: EngineInterface, s: Settings, id: string, input: { description: string; prompt: string }): Promise<void> {
+async function shadowJudge($: EngineInterface, s: Settings, id: string, input: { description: string; prompt: string }): Promise<Judged | undefined> {
   try {
     const judged = await judge($, s, input, true)
     const verdict = judged.verdict && 'domain' in judged.verdict ? judged.verdict : null
     await persistWorkerPick($, { type: 'shadow', pick: id, at: new Date(await $.clock.now()).toISOString(), verdict, rung: verdict ? rungOf(verdict) : null, judge: judged.by, ms: judged.ms, ...(judged.error ? { error: judged.error } : {}) })
-  } catch (error) { await report($, 'shadow judge', error) }
+    return judged
+  } catch (error) { await report($, 'shadow judge', error); return undefined }
 }
 
 async function toggleAuto($: EngineInterface): Promise<void> {
@@ -1219,6 +1253,7 @@ async function dashboard($: EngineInterface, working: boolean): Promise<Dashboar
     limits: await read($, limits) ?? [],
     auto: s.effortAuto, handoff: await read($, advice) ? 'advised' : s.handoffButton === 'always' ? 'always' : 'off',
     agents: { live: list.filter(a => ['running', 'waiting'].includes(a.state)).length, total: list.length },
+    compactions: await read($, compactions),
     logOpen: await read($, logOpen), agentsOpen: await read($, agentsOpen), effortMenu: await read($, effortMenuOpen),
     swampAt: s.swampAt, hide: s.hide, extras: s.extras, isWorking: working,
     ...(activeModeOf(s) ? { mode: activeModeOf(s)!.name } : {}),
@@ -1404,8 +1439,16 @@ export const register: Register = on => {
       await registerAuto($, await currentSettings($))
       startTimers($)
       // Setup keeps its draft across a reload; quick settings never keep one.
-      const open = await read($, panel)
+      let open = await read($, panel)
+      // A setup card kept from a reload while setup is done (left by a router outage) goes.
+      if (open === 'setup' && (await currentSettings($)).setupDone) {
+        await update($, panel, () => null)
+        await update($, settingsDraft, () => null)
+        await update($, settingsBase, () => null)
+        open = null
+      }
       if (open === 'setup') await rebaseDraft($)
+      if ((await currentSettings($)).judge === 'jev' && (await read($, jev)).source === null) await jevKey($)
       if (open === 'settings') { await update($, settingsDraft, () => null); await update($, settingsBase, () => null); await jevKey($) }
       if (!(await currentSettings($)).setupDone && !open) await startPanel($, 'setup')
     } catch (error) { await report($, 'session.start', error) }
@@ -1426,6 +1469,7 @@ export const register: Register = on => {
           await update($, context, () => null)
           await update($, lastRealReplyAt, () => null)
           if (await read($, kept)) await update($, kept, () => null)
+          await update($, compactions, () => 0)
         }
         if (e.model) await update($, modelIs, () => e.model!)
         await update($, paused, () => e.model ? !isCacheSafeModel(e.model) : false)
@@ -1632,11 +1676,19 @@ export const register: Register = on => {
     }
   })
   on('session.compact', async ($, e, next) => {
+    // A finished compaction of the main conversation adds one to the Compact icon's count; a skipped
+    // one, a subagent's own and the ahead-of-time precompute do not.
+    const counted = async (result: SessionCompactResult): Promise<SessionCompactResult> => {
+      try {
+        if (!e.agentId && e.trigger !== 'precompute' && 'messages' in result) await update($, compactions, n => n + 1)
+      } catch (error) { await report($, 'session.compact count', error) }
+      return result
+    }
     try {
       const language = await read($, lang)
       // The summary drops the eager note: the first prompt after it carries it again.
       if (!e.agentId && e.trigger !== 'precompute' && await read($, modeNoted) !== null) await update($, modeNoted, () => null)
-      if (e.agentId || (await currentSettings($)).compactWith !== 'haiku') return next(e)
+      if (e.agentId || (await currentSettings($)).compactWith !== 'haiku') return next(e).then(counted)
       if (e.trigger === 'precompute') return { skip: t(language, 'commands.compactSkip') }
       const transcript = serializeTranscript(e.messages.length ? e.messages : await $.session.messages())
       if (!transcript) throw new Error(t(language, 'toasts.transcriptEmpty'))
@@ -1646,12 +1698,12 @@ export const register: Register = on => {
       await update($, context, () => null)
       if (await read($, kept)) await update($, kept, () => null)
       await update($, resultCard, () => ({ stage: 'compacted' }))
-      return compactResult(answer.text)
+      return counted(compactResult(answer.text))
     } catch (error) {
       await $.ui.toast(t(await read($, lang), 'toasts.compactFallback'))
       await report($, 'session.compact', error)
     }
-    return next(e)
+    return counted(await next(e))
   })
   on('command.run', { command: 'ripple' }, async ($, e, next) => {
     try {