clauderipple 0.11.1 → 0.12.1

package/dist/mod/hooks/settings.js

@@ -21,7 +21,7 @@ export const DEFAULTS = {
                 hard: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }], plan: [claude('opus', 'high')],
             } },
     },
-    allow: [], allowKnown: [], modes: [],
+    allow: [], allowKnown: [], modes: [], delegation: 'normal',
     providers: {},
     fallback: { agent: 'general-purpose', model: 'sonnet' },
     keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
@@ -130,6 +130,25 @@ function ladderRungs(raw) {
     }
     return rungs;
 }
+/**
+ * A domain ladder folded into two levels: light and standard hold one list, hard and plan another.
+ * The upper rung of each pair wins (standard's list for the light pair, plan's for the heavy one);
+ * an empty upper rung falls back to the lower. The general ladder keeps its four rungs.
+ */
+export function twoLevelRungs(rungs) {
+    const out = {};
+    const light = rungs.standard?.length ? rungs.standard : rungs.light;
+    const heavy = rungs.plan?.length ? rungs.plan : rungs.hard;
+    if (light?.length) {
+        out.light = copy(light);
+        out.standard = copy(light);
+    }
+    if (heavy?.length) {
+        out.hard = copy(heavy);
+        out.plan = copy(heavy);
+    }
+    return out;
+}
 /**
  * The one rule left, the general ladder (the four workers). A ladder keeps its rungs; a pin from
  * before the ladder becomes one; Auto (experimental, removed 2026-10-12) becomes a ladder with no
@@ -153,6 +172,17 @@ function generalRule(raw) {
     }
     return copy(DEFAULTS.rules.general);
 }
+/** Only optional domain ladders, never the retired per-field pin/Auto rules. */
+function domainRules(raw) {
+    const source = object(raw);
+    const out = {};
+    for (const key of ['ui', 'backend']) {
+        // A domain ladder has two levels, so its four rungs are folded on the way in.
+        if (object(source[key]).mode === 'ladder')
+            out[key] = { mode: 'ladder', rungs: twoLevelRungs(generalRule(source[key]).rungs) };
+    }
+    return Object.keys(out).length ? out : undefined;
+}
 /**
  * Auto's allow-list names worker agents. Settings saved before 2026-10-10 named providers there;
  * with the worker list known, a provider name becomes that provider's workers (names it does not
@@ -242,7 +272,8 @@ export function normalizeModes(raw, base = DEFAULTS.rules.general.rungs) {
         if (!id || !name || out.some(m => m.id === id))
             continue;
         const rungs = ladderRungs(v.rungs === undefined ? base : v.rungs);
-        out.push({ id, name, rungs, delegation: v.delegation === 'eager' ? 'eager' : 'normal', until: modeUntil(v.until, rungs) });
+        const domains = domainRules(v.domainRules);
+        out.push({ id, name, rungs, ...(domains ? { domainRules: domains } : {}), delegation: v.delegation === 'eager' ? 'eager' : 'normal', until: modeUntil(v.until, rungs) });
         if (out.length === MODES_MAX)
             break;
     }
@@ -283,6 +314,7 @@ export function normalizeSettings(raw, workers) {
         result.extras = [...new Set(value.extras.filter((part) => typeof part === 'string' && EXTRAS.includes(part)))];
     const choices = {
         judge: ['haiku', 'jev', 'model'], jevSource: ['typesafe', 'zen'], bias: [-2, -1, 0, 1, 2], floor: EFFORTS,
+        delegation: ['normal', 'eager'],
         ceiling: EFFORTS, agentAuto: ['off', 'auto', 'all'], keepWarmHours: [1, 2, 4, 8], compactWith: ['haiku', 'session'],
         handoffAfter: ['continue', 'confirm', 'copy'], handoffButton: ['advised', 'always'], layout: ['dashboard', 'minimal'],
         appearance: ['auto', 'dark', 'light'], skin: SKINS, language: ['auto', 'ko', 'en', 'zh', 'ja', 'es', 'pt'],
@@ -301,6 +333,9 @@ export function normalizeSettings(raw, workers) {
     if (Array.isArray(value.hide))
         result.hide = [...new Set(value.hide.filter((part) => typeof part === 'string' && ['timer', 'reason', 'route', 'limits'].includes(part)))];
     result.fallback = target(value.fallback, DEFAULTS.fallback);
+    const domains = domainRules(value.domainRules);
+    if (domains)
+        result.domainRules = domains;
     result.modes = normalizeModes(value.modes, rules.general.rungs);
     // An active mode must be one of the modes; its start time stays only with it.
     if (typeof value.activeMode === 'string' && result.modes.some(m => m.id === value.activeMode)) {

package/dist/mod/hooks/settings.ts

@@ -1,4 +1,4 @@
-import type { Calibration, Domain, Effort, Level, Mode, Rule, Rung, Settings, SettingsChange, Skin, Step, TierTarget } from '../types/index.d.ts'
+import type { Calibration, Domain, DomainRules, Effort, Level, Mode, Rule, Rung, Settings, SettingsChange, Skin, Step, TierTarget } from '../types/index.d.ts'
 
 /** Bump whenever a writer's normalization can lose another format's fields. */
 export const MOD_SETTINGS_SCHEMA_VERSION = 1
@@ -26,7 +26,7 @@ export const DEFAULTS: Settings = {
       hard: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }], plan: [claude('opus', 'high')],
     } },
   },
-  allow: [], allowKnown: [], modes: [],
+  allow: [], allowKnown: [], modes: [], delegation: 'normal',
   providers: {},
   fallback: { agent: 'general-purpose', model: 'sonnet' },
   keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
@@ -134,6 +134,19 @@ function ladderRungs(raw: unknown): Rule['rungs'] {
   }
   return rungs
 }
+/**
+ * A domain ladder folded into two levels: light and standard hold one list, hard and plan another.
+ * The upper rung of each pair wins (standard's list for the light pair, plan's for the heavy one);
+ * an empty upper rung falls back to the lower. The general ladder keeps its four rungs.
+ */
+export function twoLevelRungs(rungs: Rule['rungs']): Rule['rungs'] {
+  const out: Rule['rungs'] = {}
+  const light = rungs.standard?.length ? rungs.standard : rungs.light
+  const heavy = rungs.plan?.length ? rungs.plan : rungs.hard
+  if (light?.length) { out.light = copy(light); out.standard = copy(light) }
+  if (heavy?.length) { out.hard = copy(heavy); out.plan = copy(heavy) }
+  return out
+}
 /**
  * The one rule left, the general ladder (the four workers). A ladder keeps its rungs; a pin from
  * before the ladder becomes one; Auto (experimental, removed 2026-10-12) becomes a ladder with no
@@ -152,6 +165,17 @@ function generalRule(raw: unknown): Rule {
   return copy(DEFAULTS.rules.general)
 }
 
+/** Only optional domain ladders, never the retired per-field pin/Auto rules. */
+function domainRules(raw: unknown): DomainRules | undefined {
+  const source = object(raw)
+  const out: DomainRules = {}
+  for (const key of ['ui', 'backend'] as const) {
+    // A domain ladder has two levels, so its four rungs are folded on the way in.
+    if (object(source[key]).mode === 'ladder') out[key] = { mode: 'ladder', rungs: twoLevelRungs(generalRule(source[key]).rungs) }
+  }
+  return Object.keys(out).length ? out : undefined
+}
+
 type Worker = { name: string; provider: string }
 
 /**
@@ -242,7 +266,8 @@ export function normalizeModes(raw: unknown, base: Rule['rungs'] = DEFAULTS.rule
     const name = typeof v.name === 'string' ? v.name.trim().slice(0, MODE_NAME_MAX) : ''
     if (!id || !name || out.some(m => m.id === id)) continue
     const rungs = ladderRungs(v.rungs === undefined ? base : v.rungs)
-    out.push({ id, name, rungs, delegation: v.delegation === 'eager' ? 'eager' : 'normal', until: modeUntil(v.until, rungs) })
+    const domains = domainRules(v.domainRules)
+    out.push({ id, name, rungs, ...(domains ? { domainRules: domains } : {}), delegation: v.delegation === 'eager' ? 'eager' : 'normal', until: modeUntil(v.until, rungs) })
     if (out.length === MODES_MAX) break
   }
   return out
@@ -275,6 +300,7 @@ export function normalizeSettings(raw: unknown, workers?: readonly Worker[]): Se
   if (Array.isArray(value.extras)) result.extras = [...new Set(value.extras.filter((part): part is string => typeof part === 'string' && EXTRAS.includes(part)))]
   const choices = {
     judge: ['haiku', 'jev', 'model'], jevSource: ['typesafe', 'zen'], bias: [-2, -1, 0, 1, 2], floor: EFFORTS,
+    delegation: ['normal', 'eager'],
     ceiling: EFFORTS, agentAuto: ['off', 'auto', 'all'], keepWarmHours: [1, 2, 4, 8], compactWith: ['haiku', 'session'],
     handoffAfter: ['continue', 'confirm', 'copy'], handoffButton: ['advised', 'always'], layout: ['dashboard', 'minimal'],
     appearance: ['auto', 'dark', 'light'], skin: SKINS, language: ['auto', 'ko', 'en', 'zh', 'ja', 'es', 'pt'],
@@ -286,6 +312,8 @@ export function normalizeSettings(raw: unknown, workers?: readonly Worker[]): Se
   if (typeof value.swampAt === 'number' && Number.isFinite(value.swampAt) && value.swampAt >= 0 && value.swampAt <= 100) result.swampAt = value.swampAt
   if (Array.isArray(value.hide)) result.hide = [...new Set(value.hide.filter((part): part is string => typeof part === 'string' && ['timer', 'reason', 'route', 'limits'].includes(part)))]
   result.fallback = target(value.fallback, DEFAULTS.fallback)!
+  const domains = domainRules(value.domainRules)
+  if (domains) result.domainRules = domains
   result.modes = normalizeModes(value.modes, rules.general.rungs)
   // An active mode must be one of the modes; its start time stays only with it.
   if (typeof value.activeMode === 'string' && result.modes.some(m => m.id === value.activeMode)) {

package/dist/mod/hooks/ui/agents.tsx

@@ -93,7 +93,7 @@ function typeOf(agent: AgentRec, model: string): string {
 function whyLine(frame: Frame, agent: AgentRec): string {
   const pick = agent.pick
   if (!pick) return ''
-  const parts = [t(frame.lang, 'agents.by', { name: t(frame.lang, BY[pick.by]) }) + ' · ' + t(frame.lang, 'agents.domainLevel', { domain: t(frame.lang, 'workers.' + pick.domain), level: t(frame.lang, 'settings.' + pick.level) }) + (pick.rung ? ' · ' + t(frame.lang, 'workers.rung.' + pick.rung) : '')]
+  const parts = [t(frame.lang, 'agents.by', { name: t(frame.lang, BY[pick.by]) }) + ' · ' + t(frame.lang, 'agents.domainLevel', { domain: t(frame.lang, 'workers.' + pick.domain), level: t(frame.lang, 'settings.' + pick.level) }) + (pick.rung ? ' · ' + (pick.rule ?? 'general') + '/' + t(frame.lang, 'workers.rung.' + pick.rung) : '')]
   if (pick.why) parts.push('“' + pick.why + '”')
   return parts.join(' · ')
 }

package/dist/mod/hooks/ui/art.ts

@@ -609,14 +609,19 @@ export function iconArt(icon: Icon, on: boolean, tone: Tone = 'violet'): string
 
 export const AGENTS_W = 26
 
-/** The agents icon with the live count in a lit disc on its shoulder, one width whatever the count. */
-export function agentsArt(count: number, on: boolean): string {
+/** A control's icon with a count in a lit disc on its shoulder, one width whatever the count. */
+export function countedArt(icon: Icon, count: number, on: boolean): string {
   const stroke = on ? TONE.violet.hi : SOFT
   const label = count > 9 ? '9+' : String(count)
   const badge = count > 0
     ? '<circle cx="20" cy="5.5" r="5.5" fill="#22d3ee"/><text x="20" y="8.6" text-anchor="middle" font-size="' + (label.length > 1 ? 7 : 8.5) + '" font-weight="750" fill="#04252e">' + label + '</text>'
     : ''
-  return svg(AGENTS_W, 16, '<g transform="translate(0 .5)" fill="none" stroke="' + stroke + '" stroke-width="1.45" stroke-linecap="round" stroke-linejoin="round">' + ICON.agents + '</g>' + badge, '', lit(on))
+  return svg(AGENTS_W, 16, '<g transform="translate(0 .5)" fill="none" stroke="' + stroke + '" stroke-width="1.45" stroke-linecap="round" stroke-linejoin="round">' + ICON[icon] + '</g>' + badge, '', lit(on))
+}
+
+/** The agents icon with the live count on its shoulder. */
+export function agentsArt(count: number, on: boolean): string {
+  return countedArt('agents', count, on)
 }
 
 /** A thin upright rule between the band's groups, 1 × 14 px in a 9 px slot. */

package/dist/mod/hooks/ui/band.tsx

@@ -309,7 +309,7 @@ function controls(frame: Frame, view: DashboardView, actions: BandActions): Cont
     // The count has a slot of its own (desktop) or is always a number (terminal): no width change.
     { key: 'agents', label: t(L, 'band.agents') + (isRich(frame) ? '' : ' ' + (view.agents.live || '·')) + mark(view.agentsOpen), hotkey: 'g', onPress: actions.toggleAgents, on: view.agentsOpen, ...(isRich(frame) ? { count: view.agents.live > 0 ? String(view.agents.live) : '' } : {}) },
     // The desktop's Clear asks first (a card of its own, "clear" in bandPriority); Compact opens its note bar.
-    ...(isRich(frame) ? [{ key: 'compact', label: t(L, 'band.compact'), hotkey: 'c', onPress: actions.compact, on: false }, { key: 'clear', label: t(L, 'band.clear'), hotkey: 'x', onPress: actions.clear, on: false }] : []),
+    ...(isRich(frame) ? [{ key: 'compact', label: t(L, 'band.compact'), hotkey: 'c', onPress: actions.compact, on: false, count: view.compactions > 0 ? String(view.compactions) : '' }, { key: 'clear', label: t(L, 'band.clear'), hotkey: 'x', onPress: actions.clear, on: false }] : []),
     // A word on the desktop: the host's 14 px font draws ⚙ as a small ring that reads as "o".
     { key: 'settings', label: isRich(frame) ? t(L, 'band.settings') : '⚙', hotkey: 's', onPress: actions.openSettings, on: false },
   )
@@ -786,7 +786,11 @@ function controlsDrawn(el: Els, frame: Frame, view: DashboardView, actions: Band
   // The live count sits on the icon's shoulder, in one picture of one width: no width change.
   out.push(iconControl(el, frame, 'agents', k.art.agents(live, view.agentsOpen || live > 0), AGENTS_W, live > 0 ? agentsLabel + ' ' + live : agentsLabel, t(L, 'band.agentsAlt', { count: live }), actions.toggleAgents, words.includes('agents') ? agentsLabel : undefined, view.agentsOpen ? k.ink : k.sub))
   const compactLabel = t(L, 'band.compact')
-  out.push(iconControl(el, frame, 'compact', k.art.icon('compact', false), ICON_PX, compactLabel, t(L, 'band.compactAlt'), actions.compact, words.includes('compact') ? compactLabel : undefined))
+  // How many times the chat was compacted sits on the icon's shoulder, as the agents' live count
+  // does, in one picture of one width: the first compaction moves no neighbour.
+  const compactions = view.compactions
+  const compactTip = t(L, 'band.compactAlt') + (compactions > 0 ? ' · ' + t(L, 'band.compactedTimes', { count: compactions }) : '')
+  out.push(iconControl(el, frame, 'compact', k.art.counted('compact', compactions, false), AGENTS_W, compactions > 0 ? compactLabel + ' ' + compactions : compactLabel, compactTip, actions.compact, words.includes('compact') ? compactLabel : undefined))
   const clearLabel = t(L, 'band.clear')
   out.push(iconControl(el, frame, 'clear', k.art.icon('clear', false), ICON_PX, clearLabel, t(L, 'band.clearAlt'), actions.clear, words.includes('clear') ? clearLabel : undefined))
   const settingsLabel = t(L, 'band.settings')

package/dist/mod/hooks/ui/flat.ts

@@ -8,7 +8,7 @@
 // laid over the pictures line up (kit.tsx). Pure: SVG only, so node tests can load it.
 
 import { AGENTS_W, CELL_PX, CLOSE_PX, CONTROL_PX, FLAME, GLYPH, ICON, ICON_PX, METER_H, METER_W, SWITCH_H, SWITCH_W, TILE_PX, esc, labelPx, r } from './art.ts'
-import type { Tone } from './art.ts'
+import type { Icon, Tone } from './art.ts'
 import type { Paint } from './look.ts'
 import { svgDoc } from './theme.ts'
 import type { Appearance } from './theme.ts'
@@ -55,6 +55,14 @@ export function flatPictures(appearance: Appearance): Paint {
   /** A rule for `sel` that follows the theme: `light` on a light app, `dark` on a dark one. */
   const themed = (sel: string, light: string, dark: string): string =>
     appearance === 'dark' ? sel + '{' + dark + '}' : appearance === 'light' ? sel + '{' + light + '}' : sel + '{' + light + '}@media (prefers-color-scheme:dark){' + sel + '{' + dark + '}}'
+  /** A control's icon with a count in an accent disc on its shoulder, one width whatever the count. */
+  const counted = (icon: Icon, count: number, on: boolean): string => {
+    const text = count > 9 ? '9+' : String(count)
+    const badge = count > 0
+      ? '<circle cx="20" cy="5.5" r="5.5" fill="' + ACCENT + '"/><text x="20" y="8.6" text-anchor="middle" font-size="' + (text.length > 1 ? 7 : 8.5) + '" font-weight="750"' + fillOf('#fff') + '>' + text + '</text>'
+      : ''
+    return doc(AGENTS_W, 16, '<g transform="translate(0 .5)" fill="none" stroke="' + (on ? ACCENT : MUTED) + '" stroke-width="1.45" stroke-linecap="round" stroke-linejoin="round">' + ICON[icon] + '</g>' + badge)
+  }
 
   return {
     // The capsule is the app's own surface, as its prompt box is: white on a light app, its dark
@@ -203,13 +211,8 @@ export function flatPictures(appearance: Appearance): Paint {
       return doc(ICON_PX, ICON_PX, '<g fill="none" stroke="' + (on ? ACCENT : MUTED) + '" stroke-width="1.45" stroke-linecap="round" stroke-linejoin="round">' + ICON[icon] + '</g>')
     },
 
-    agents: (count, on) => {
-      const text = count > 9 ? '9+' : String(count)
-      const badge = count > 0
-        ? '<circle cx="20" cy="5.5" r="5.5" fill="' + ACCENT + '"/><text x="20" y="8.6" text-anchor="middle" font-size="' + (text.length > 1 ? 7 : 8.5) + '" font-weight="750"' + fillOf('#fff') + '>' + text + '</text>'
-        : ''
-      return doc(AGENTS_W, 16, '<g transform="translate(0 .5)" fill="none" stroke="' + (on ? ACCENT : MUTED) + '" stroke-width="1.45" stroke-linecap="round" stroke-linejoin="round">' + ICON.agents + '</g>' + badge)
-    },
+    agents: (count, on) => counted('agents', count, on),
+    counted: (icon, count, on) => counted(icon, count, on),
 
     rule: () => doc(9, 16, '<rect x="4" y="1" width="1" height="14" rx=".5" fill="' + STROKE + '"/>'),
 

package/dist/mod/hooks/ui/look.ts

@@ -41,6 +41,8 @@ export type Paint = {
   gauge: (kind: string) => string
   icon: (icon: Icon, on: boolean, tone?: Tone) => string
   agents: (count: number, on: boolean) => string
+  /** An icon with a count on its shoulder (the chat's compactions). */
+  counted: (icon: Icon, count: number, on: boolean) => string
   rule: () => string
   tile: (art: TileArt) => string
   beads: (step: number, total: number) => { source: string; width: number }
@@ -70,7 +72,7 @@ const DEEP_PAINT: Paint = {
   sea: deep.seaArt, plate: deep.plateArt, switch: deep.switchArt, word: deep.wordArt, extraHover: deep.extraHoverArt,
   pill: deep.pillArt, segmented: deep.segmentedArt, slider: deep.sliderArt, well: deep.wellArt, close: deep.closeArt,
   meter: deep.meterArt, ring: deep.ringArt, clock: deep.clockArt, gauge: deep.gaugeArt, icon: deep.iconArt,
-  agents: deep.agentsArt, rule: deep.ruleArt, tile: deep.tileArt, beads: deep.beadsArt,
+  agents: deep.agentsArt, counted: deep.countedArt, rule: deep.ruleArt, tile: deep.tileArt, beads: deep.beadsArt,
 }
 
 /** The deep: the capsule's edge a warm grey that reads on a light page and a dark one alike, lights white on the water. */

package/dist/mod/hooks/ui/view.ts

@@ -82,6 +82,8 @@ export type DashboardView = {
   /** Compact turns into a lit Handoff when advice says so, or always with handoffButton 'always'. */
   handoff: 'off' | 'advised' | 'always'
   agents: { live: number; total: number }
+  /** Times this chat was compacted (manual, automatic or by the band), shown on the Compact icon. */
+  compactions: number
   logOpen: boolean
   agentsOpen: boolean
   /** The manual effort row is open. */

package/dist/mod/hooks/workers.ts

@@ -1,4 +1,4 @@
-import type { Billing, Domain, Effort, LadderChoice, LadderOptions, Level, ModelScore, RouterModel, Rule, Rung, Settings, TierTarget, WorkerCandidate, WorkerVerdict } from '../types'
+import type { Billing, Domain, Effort, LadderChoice, LadderOptions, Level, ModelScore, RouterModel, Rule, Rung, Settings, TierTarget, WorkerCandidate, WorkerPick, WorkerVerdict } from '../types'
 import { CLAUDE_WORKERS, DOMAINS, EFFORTS, LEVELS, candidateKey, isAllowed } from './settings'
 import { MARKER } from './worker'
 import { t } from './i18n'
@@ -164,6 +164,27 @@ function sameTarget(a: TierTarget, b: TierTarget): boolean { return a.agent ===
 function candidateOf(target: TierTarget, candidates: readonly WorkerCandidate[]): WorkerCandidate | undefined {
   return candidates.find(c => sameTarget(c.target, target)) ?? (target.agent === 'general-purpose' ? { target, model: target.model ?? 'sonnet', provider: candidates.find(c => c.model === baseModel(target.model ?? 'sonnet'))?.provider ?? 'anthropic' } : undefined)
 }
+/** Domain overrides belong to the effective worker set; a missing override uses its general ladder. */
+export function workerRule(domain: Domain, settings: Settings): { rule: WorkerPick['rule']; ladder: Rule } {
+  const key = domain === 'design' || domain === 'frontend' ? 'ui' : domain === 'backend' ? 'backend' : 'general'
+  const ladder = key === 'general' ? undefined : settings.domainRules?.[key]
+  return ladder ? { rule: key, ladder } : { rule: 'general', ladder: settings.rules.general }
+}
+
+/**
+ * Visual design depends on the model's taste, not on how hard the task is (2026-10-21: a store
+ * screenshot redesign judged "design, standard" ran on the light pair). Under the ui ladder a design
+ * verdict on the light or standard rung is raised to the hard rung; frontend, other ladders and
+ * verdicts already on hard or plan are untouched.
+ */
+export function domainVerdict(verdict: WorkerVerdict, rule: WorkerPick['rule']): { verdict: WorkerVerdict; raised?: 'design' } {
+  if (rule !== 'ui' || verdict.domain !== 'design') return { verdict }
+  const rung = rungOf(verdict)
+  if (rung !== 'light' && rung !== 'standard') return { verdict }
+  const { sure: _sure, ...rest } = verdict
+  return { verdict: { ...rest, ...TIER_MARKERS.hard! }, raised: 'design' }
+}
+
 export type Resolution = { target?: TierTarget; effort: Effort; rung?: Rung; position?: number; skipped?: { rung: Rung; position: number; model: string; reason: string }[]; fallbackReason?: string }
 
 /** Claude Code's own agent with no model: the subagent runs on the session's model. */

package/dist/mod/tests/delegation.test.tsx

@@ -0,0 +1,50 @@
+// Base's delegation (docs/specs/2026-10-12-worker-tiers.md "Screens"): while no mode is on, the
+// eager note is Base's; a mode that is on uses its own delegation instead.
+import { expect, test } from 'claude-code/testing'
+import { DEFAULTS, normalizeSettings } from '../hooks/settings'
+import { eagerNote, modeNote } from '../hooks/modes'
+import type { Mode, Settings } from '../types'
+
+const BASE_NOTE = 'ClaudeRipple: delegate everything except judgment and final review to ripple:auto.'
+
+function settings(patch: Partial<Settings> = {}): Settings {
+  return { ...normalizeSettings(null), ...patch }
+}
+
+const MODES: Mode[] = [
+  { id: 'calm', name: 'Calm', rungs: {}, delegation: 'normal', until: 'none' },
+  { id: 'burn', name: 'Burn', rungs: {}, delegation: 'eager', until: 'none' },
+]
+
+test('Base eager notes the main chat once, then not again until a compaction clears it', () => {
+  const s = settings({ delegation: 'eager' })
+  expect(eagerNote(s, null)).toEqual({ note: BASE_NOTE, noted: 'base' })
+  expect(eagerNote(s, 'base')).toEqual({ noted: 'base' })
+  // The compaction clears `noted` (register.tsx), so the first prompt after it carries the note again.
+  expect(eagerNote(s, null).note).toBe(BASE_NOTE)
+})
+
+test('Base normal says nothing and clears what was noted, so eager again sends it afresh', () => {
+  const s = settings({ delegation: 'normal' })
+  expect(eagerNote(s, null)).toEqual({ noted: null })
+  expect(eagerNote(s, 'base')).toEqual({ noted: null })
+})
+
+test("a mode's delegation wins over Base, either way", () => {
+  // A normal mode on an eager Base: no note, and the earlier Base note is cleared.
+  const calmOnEagerBase = normalizeSettings({ delegation: 'eager', modes: MODES, activeMode: 'calm', activeSince: 5 })
+  expect(eagerNote(calmOnEagerBase, 'base')).toEqual({ noted: null })
+  // An eager mode on a normal Base: the mode's note, once per turning-on.
+  const burnOnNormalBase = normalizeSettings({ delegation: 'normal', modes: MODES, activeMode: 'burn', activeSince: 5 })
+  const first = eagerNote(burnOnNormalBase, null)
+  expect(first).toEqual({ note: modeNote('Burn'), noted: 'burn@5' })
+  expect(eagerNote(burnOnNormalBase, first.noted)).toEqual({ noted: 'burn@5' })
+})
+
+test('normalizeSettings keeps a stored delegation and defaults anything else to normal', () => {
+  expect(DEFAULTS.delegation).toBe('normal')
+  expect(normalizeSettings(null).delegation).toBe('normal')
+  expect(normalizeSettings({ delegation: 'loud' }).delegation).toBe('normal')
+  expect(normalizeSettings({ delegation: 'eager' }).delegation).toBe('eager')
+  expect(normalizeSettings(normalizeSettings({ delegation: 'eager' })).delegation).toBe('eager')
+})

package/dist/mod/tests/register.test.tsx

@@ -270,6 +270,37 @@ test('empty router uses defaults without writing when there is no legacy store',
   await ui.unmount()
 })
 
+// 2026-10-20: a stray test router took the live router's launchd label for five minutes and answered
+// with nothing stored; every chat took its defaults, opened setup and asked for the Jev key again,
+// and kept asking after the real router came back.
+test('a router that lost its settings gets this chat\'s back instead of opening setup', async ($, on) => {
+  const b = boundaries(on)
+  b.remote({ settings: normalizeSettings({ setupDone: true, language: 'pt', keepWarm: true }), revision: 7, stored: true })
+  http(on)
+  await start($)
+  expectLanguage(b, 'pt')
+  b.remote({ settings: normalizeSettings(null), revision: 0, stored: false })
+  await b.clock.advance(3000)
+  const ui = await band($)
+  expect(await ui.find({ type: 'Text', text: 'Welcome to ClaudeRipple' })).toBeUndefined()
+  expectLanguage(b, 'pt')
+  expect(b.router()).toMatchObject({ stored: true, settings: { setupDone: true, language: 'pt', keepWarm: true } })
+  await ui.unmount()
+})
+
+test('a setup card left open closes once the router says setup is done', async ($, on) => {
+  const b = boundaries(on)
+  b.remote({ settings: normalizeSettings(null), revision: 0, stored: false })
+  http(on)
+  await start($)
+  const ui = await band($)
+  expect(await ui.find({ type: 'Text', text: 'Welcome to ClaudeRipple' })).toBeDefined()
+  b.remote({ settings: normalizeSettings({ setupDone: true }), revision: 3, stored: true })
+  await b.clock.advance(3000)
+  expect(await ui.find({ type: 'Text', text: 'Welcome to ClaudeRipple' })).toBeUndefined()
+  await ui.unmount()
+})
+
 test('legacy settings and setup completion migrate once; unrelated store keys survive', async ($, on) => {
   const b = boundaries(on)
   b.remote({ settings: normalizeSettings(null), revision: 0, stored: false })
@@ -494,7 +525,7 @@ test('ripple:auto is judged and rewritten to the light rung\'s agent at the rung
   expect(b.logs.length).toBe(1)
   expect(b.logs[0]!.startsWith('ClaudeRipple worker pick: ')).toBe(true)
   expect(JSON.parse(b.logs[0]!.slice('ClaudeRipple worker pick: '.length))).toEqual({
-    task: 'Rename variable', domain: 'general', level: 'light', kind: 'do', sure: 0.9, rung: 'light', position: 1, skipped: [],
+    task: 'Rename variable', domain: 'general', level: 'light', kind: 'do', sure: 0.9, rule: 'general', rung: 'light', position: 1, skipped: [],
     target: { agent: 'deepseek-v4-1-flash' }, model: 'deepseek-v4.1-flash@max', effort: 'max', by: 'haiku',
   })
   const persisted = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!
@@ -621,6 +652,102 @@ for (const [tier, rung, agent, model] of [
   expect(b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').filter(line => line.includes('"outcome"')).length).toBe(1)
 })
 
+for (const domain of ['design', 'frontend', 'backend', 'docs'] as const) test(`auto selects the ${domain} task's domain ladder or its own general fallback`, async ($, on) => {
+  const b = boundaries(on, { domainRules: {
+    ui: { mode: 'ladder', rungs: { light: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }], hard: [{ target: { agent: 'gpt-6-1-sol' }, effort: 'high' }] } },
+    backend: { mode: 'ladder', rungs: { light: [{ target: { agent: 'gpt-6-1-sol' }, effort: 'medium' }] } },
+  } })
+  http(on)
+  judgeStub(on, JSON.stringify({ domain, level: 'light', kind: 'do', effort: 'low', sure: 0.9, why: 'domain' }))
+  const sent = spawnStub(on)
+  await start($)
+  await $.agent.spawn(SPAWN)
+  const rule = domain === 'design' || domain === 'frontend' ? 'ui' : domain === 'backend' ? 'backend' : 'general'
+  // A light design verdict is raised to the heavy pair (visual taste, not difficulty); frontend keeps its level.
+  const raised = domain === 'design'
+  expect(sent[0]?.subagentType).toBe(rule === 'ui' ? (raised ? 'gpt-6-1-sol' : 'gpt-6-astra') : rule === 'backend' ? 'gpt-6-1-sol' : 'deepseek-v4-1-flash')
+  const row = JSON.parse(b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!)
+  expect(row).toMatchObject({ rule, domain, level: 'light', rung: raised ? 'hard' : 'light' })
+  expect(row.raised).toBe(raised ? 'design' : undefined)
+})
+
+test('a design task under the ui ladder takes the heavy level past a tier marker', async ($, on) => {
+  const b = boundaries(on, { domainRules: { ui: { mode: 'ladder', rungs: { light: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }], hard: [{ target: { agent: 'gpt-6-1-sol' }, effort: 'high' }] } } } })
+  http(on)
+  judgeStub(on, JSON.stringify({ domain: 'design', level: 'deep', kind: 'do', effort: 'high', sure: 0.9, why: 'domain' }))
+  const sent = spawnStub(on)
+  await start($)
+  await $.agent.spawn({ ...SPAWN, prompt: '[[ripple: light]]\nTweak a color.' })
+  expect(sent[0]?.subagentType).toBe('gpt-6-1-sol')
+  const row = JSON.parse(b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').find(line => line.includes('"type":"pick"'))!)
+  expect(row).toMatchObject({ by: 'session', rule: 'ui', domain: 'design', rung: 'hard', raised: 'design' })
+})
+
+for (const domains of [false, true]) test(`tier marker ${domains ? 'awaits' : 'does not await'} one pending shadow judge with domain ladders ${domains ? 'on' : 'off'}`, async ($, on) => {
+  const b = boundaries(on, domains ? { domainRules: { ui: { mode: 'ladder', rungs: { light: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }] } } } } : {})
+  http(on)
+  let release!: () => void
+  const pending = new Promise<void>(resolve => { release = resolve })
+  let calls = 0
+  on('model.complete', async () => {
+    calls++
+    await pending
+    return { value: { isAnswered: true, text: JSON.stringify({ domain: 'frontend', level: 'deep', kind: 'plan', effort: 'max', sure: 0.1, why: 'conflicts with tier' }), usage: USAGE } }
+  })
+  const sent = spawnStub(on)
+  await start($)
+  const spawn = $.agent.spawn({ ...SPAWN, prompt: '[[ripple: light]]\nBuild the UI.' })
+  await b.clock.settle()
+  expect(calls).toBe(1)
+  expect(sent.length).toBe(domains ? 0 : 1)
+  release()
+  await spawn
+  await b.clock.settle()
+  expect(calls).toBe(1)
+  expect(sent[0]?.subagentType).toBe(domains ? 'gpt-6-astra' : 'deepseek-v4-1-flash')
+  const rows = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').map(line => JSON.parse(line))
+  const pick = rows.find(row => row.type === 'pick')
+  expect(pick).toMatchObject({ by: 'session', tier: 'light', rung: 'light', level: 'light', kind: 'do', rule: domains ? 'ui' : 'general', domain: domains ? 'frontend' : 'general' })
+  expect(pick.sure).toBeUndefined()
+  expect(rows.filter(row => row.type === 'shadow').length).toBe(1)
+  expect(rows.find(row => row.type === 'shadow')).toMatchObject({ pick: pick.id, rung: 'plan', verdict: { domain: 'frontend', sure: 0.1 } })
+})
+
+for (const error of ['api-error', 'aborted'] as const) test(`a marker retains its tier and uses general when its domain judge is ${error}`, async ($, on) => {
+  const b = boundaries(on, { domainRules: { ui: DEFAULTS.rules.general } })
+  http(on)
+  on('model.complete', async () => {
+    if (error === 'aborted') await b.clock.advance(6000)
+    return { value: error === 'aborted' ? { isAnswered: false, reason: 'aborted', usage: USAGE } : { isAnswered: false, reason: 'api-error', status: 503, error: 'overloaded', usage: USAGE } }
+  })
+  const sent = spawnStub(on)
+  await start($)
+  await $.agent.spawn({ ...SPAWN, prompt: '[[ripple: light]]\nRename a variable.' })
+  expect(sent[0]?.subagentType).toBe('deepseek-v4-1-flash')
+  const rows = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').map(line => JSON.parse(line))
+  expect(rows.find(row => row.type === 'pick')).toMatchObject({ by: 'session', domain: 'general', rule: 'general', rung: 'light', tier: 'light', verdict: null })
+  expect(rows.filter(row => row.type === 'shadow').length).toBe(1)
+})
+
+test('a mode without domain rules skips awaiting Base domains; explicit model markers still bypass the judge', async ($, on) => {
+  const b = boundaries(on, { domainRules: { ui: DEFAULTS.rules.general }, modes: [{ id: 'plain', name: 'Plain', rungs: DEFAULTS.rules.general.rungs, delegation: 'normal', until: 'none' }], activeMode: 'plain' })
+  http(on)
+  const judges = judgeStub(on, '{"domain":"frontend","level":"light","effort":"low","sure":0.9}')
+  const sent = spawnStub(on)
+  await start($)
+  await $.agent.spawn({ ...SPAWN, prompt: '[[ripple: light]]\nWork.' })
+  await b.clock.settle()
+  const rows = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').map(line => JSON.parse(line))
+  expect(rows.find(row => row.type === 'pick')).toMatchObject({ domain: 'general', rule: 'general', mode: 'Plain', verdict: null })
+  expect(judges.length).toBe(1)
+  // Turn Base on, so its domain override is effective for this explicit marker.
+  b.remote({ settings: normalizeSettings({ setupDone: true, domainRules: { ui: DEFAULTS.rules.general } }), revision: 2, stored: true })
+  await b.clock.advance(3000)
+  await $.agent.spawn({ ...SPAWN, prompt: '[[ripple: gpt-6-astra@max]]\nWork.' })
+  expect(judges.length).toBe(1)
+  expect(sent[1]).toMatchObject({ subagentType: 'gpt-6-astra', model: 'gpt-6-astra@max' })
+})
+
 test('the limits row shows Claude\'s plan on a chat that runs on another provider', async ($, on) => {
   const b = boundaries(on, { extras: ['limits'] })
   b.setModel('muse-spark-1.3-contributor')
@@ -1089,6 +1216,32 @@ test('failed Haiku compaction falls back; precompute skips; subagent stays with
   expect(b.toasts.some(t => t.includes('session compactor'))).toBe(true)
 })
 
+test('the Compact icon counts the main chat\'s finished compactions; /clear zeroes it', async ($, on) => {
+  boundaries(on, { compactWith: 'session' })
+  http(on)
+  on('session.compact', () => ({ messages: MESSAGES }))
+  await start($)
+  const alt = async (ui: Awaited<ReturnType<typeof band>>) => {
+    const box = await ui.find({ key: 'pic-compact' })
+    return (box?.children[0] as { props?: { alt?: unknown } } | undefined)?.props?.alt
+  }
+  let ui = await band($, 'desktop')
+  expect(await alt(ui)).toBe('Compact')
+  await ui.unmount()
+  await $.session.compact({ trigger: 'manual', messages: MESSAGES })
+  await $.session.compact({ trigger: 'auto', messages: MESSAGES })
+  // Neither a subagent's own compaction nor the ahead-of-time precompute is the chat's.
+  await $.session.compact({ trigger: 'auto', messages: MESSAGES, agentId: 'worker' })
+  await $.session.compact({ trigger: 'precompute', messages: MESSAGES })
+  ui = await band($, 'desktop')
+  expect(await alt(ui)).toBe('Compact 2')
+  await ui.unmount()
+  await $.classic.SessionStart({ source: 'clear' })
+  ui = await band($, 'desktop')
+  expect(await alt(ui)).toBe('Compact')
+  await ui.unmount()
+})
+
 // ---- Operating modes (docs/specs/2026-10-12-worker-tiers.md "Operating modes") -----------------
 
 const BURN = normalizeModes([{ id: 'burn', name: 'Burn GPT', rungs: { ...DEFAULTS.rules.general.rungs, light: [{ target: { agent: 'gpt-6-1-sol' }, effort: 'low' }] }, delegation: 'eager' }])

package/dist/mod/tests/ui.test.tsx

@@ -57,6 +57,7 @@ const DASH: DashboardView = {
   auto: true,
   handoff: 'off',
   agents: { live: 0, total: 0 },
+  compactions: 0,
   logOpen: false,
   agentsOpen: false,
   effortMenu: false,
@@ -574,7 +575,7 @@ const AGENTS: AgentRec[] = [
     description: 'Port the request log renderer',
     type: 'gpt-6-1-sol',
     model: 'gpt-6.1-sol@high',
-    pick: { domain: 'frontend', level: 'standard', effort: 'high', sure: 0.8, why: 'designed refactor', target: { agent: 'gpt-6-1-sol' }, by: 'haiku', ms: 900 },
+    pick: { domain: 'frontend', rule: 'ui', rung: 'standard', level: 'standard', effort: 'high', sure: 0.8, why: 'designed refactor', target: { agent: 'gpt-6-1-sol' }, by: 'haiku', ms: 900 },
     state: 'running',
     now: 'Edit hooks/ui/log.tsx',
     toolSince: NOW - 14_000,
@@ -618,8 +619,10 @@ test('the Agents pane draws live, finished and empty', async ($, on) => {
     expect(await ui.find({ type: 'Text', text: 'Summarize the docs' }), surface).toBeDefined()
     // Who picked it and why, on the terminal; the desktop's cards leave it out (2026-10-20).
     const why = await ui.find({ type: 'Text', text: /Frontend \/ Standard/ })
-    if (surface === 'terminal') expect(why, surface).toBeDefined()
-    else expect(why, surface).toBeUndefined()
+    if (surface === 'terminal') {
+      expect(why, surface).toBeDefined()
+      expect(why?.text).toContain('ui/')
+    } else expect(why, surface).toBeUndefined()
     // The API's own counts: 1200 + 38000 + 800 in, 95% of it from the cache, 5100 out, 12 tools.
     if (surface === 'terminal') expect(await ui.find({ type: 'Text', text: 'in 40k · cache 95% · out 5.1k · tools 12' }), surface).toBeDefined()
     else for (const value of ['40k', '95%', '5.1k', '12']) expect(await ui.find({ type: 'Text', text: value }), value).toBeDefined()