agentbox-app 0.1.13 → 0.1.16

package/main/config.mjs

@@ -34,7 +34,7 @@ const CONFIG_NAME = 'zero.config.json';
  */
 export const DEFAULT_SESSIONS_AT_ONCE = 3;
 
-const DEFAULTS = {
+export const DEFAULTS = {
   // ONE ACCOUNT FOLDER PER INSTALL, AND NOBODY ELSE'S.
   //
   // This was a literal id for most of the app's life, which meant every copy
@@ -76,6 +76,16 @@ const DEFAULTS = {
   // commands may run at once; null is Auto, one per 8 GB.
   memoryGate: false,
   memoryGateSlots: null,
+  // RUN THE OVERFLOW IN THE CLOUD (docs/cloud/PLAN.md). Null is "when this Mac
+  // has been set up for it": nothing happens anywhere until somebody has run
+  // scripts/cloud-setup.mjs and an account has signed in from the cloud menu,
+  // and before that the app is exactly the app it was. `false` turns it off
+  // even then.
+  // `maxCloudSessions` is the cloud's own cap, apart from this Mac's. Null is
+  // what this Mac can carry: 50 through the shared host (about 11 MB a run),
+  // 20 where each run needs a relay of its own (about 110 MB a run).
+  cloudRuns: null,
+  maxCloudSessions: null,
   // STOP WHAT FINISHED AGENTS LEAVE RUNNING (main/leftovers.mjs). Its own
   // switch, off until somebody turns it on; `cleanupLeftoversSince` is the
   // moment they did, so nothing is stopped sooner than the idle time after it.

package/main/corner-tag.mjs

@@ -37,7 +37,7 @@
 // is, so it hands over what is ready and how many are working on
 // `zero:corner-tag`; shared/corner-tag.mjs puts it newest first.
 
-import { cardPlacement, hiddenUntil, keepCorner, readyNow, restingSpot, tagShows, HIDE_CHOICES } from '../shared/corner-tag.mjs';
+import { cardPlacement, cornerPlace, heightFromDrag, EDGE_SLACK, hiddenUntil, keepCorner, newSince, notDismissed, readyNow, restingSpot, spotFor, tagScaleOn, tagShows, tagZoom, zoomFor, zoomStep, GRIPS, HIDE_CHOICES } from '../shared/corner-tag.mjs';
 
 // How long the pointer may be off both the tag and its list before the list
 // shuts: long enough to cross the gap between them, short enough to feel like
@@ -52,16 +52,32 @@ export const DRAG_FROM_PX = 6;
 const FRAME_MS = 16;
 // A press whose release never came is let go after this long.
 const PRESS_GIVES_UP_MS = 60_000;
+// How often the Mac's glass is asked whether it went light or dark, while the
+// tray is on screen and only then. Drag the tray from a white page onto a dark
+// one and the ink follows within this.
+export const TONE_EVERY_MS = 500;
+// How often the page is asked to measure again while the tray is on screen.
+// The glass is placed from what the page last said, and once (w-93b3a1a796)
+// it was left at an old size by something that was never reproduced; this is
+// the longest that can now last.
+export const MEASURE_EVERY_MS = 2000;
 
 const HIDE_LABELS = { '5m': 'Hide for 5 minutes', '30m': 'Hide for 30 minutes', today: 'Hide for the rest of today' };
 const CHANNELS = [
   'zero:corner-tag', 'corner-tag:ready', 'corner-tag:size', 'corner-tag:hover', 'corner-tag:toggle',
   'corner-tag:press', 'corner-tag:release', 'corner-tag:go', 'corner-tag:hide', 'corner-tag:settings', 'corner-tag:menu',
+  'corner-tag:clickable', 'corner-tag:resize', 'corner-tag:dismiss',
 ];
 
 export function createCornerTag({
   BrowserWindow, screen, ipcMain, Menu, powerMonitor, config, saveConfig, mainWindow, load, preload,
-  now = () => Date.now(), setTimer = setTimeout, clearTimer = clearTimeout, mac = process.platform === 'darwin',
+  count = () => {}, now = () => Date.now(), setTimer = setTimeout, clearTimer = clearTimeout, mac = process.platform === 'darwin',
+  // The Mac's own Liquid Glass (main/liquid-glass.mjs), or null, and then the
+  // page draws a glass of its own.
+  glass = null,
+  // What a notification has told you about since you were last at the app,
+  // [{ id, at }] (main/notify.mjs). All of it counts as new.
+  told = () => [],
 }) {
   const wins = { tag: null, card: null };
   const loaded = { tag: false, card: false };
@@ -85,37 +101,168 @@ export function createCornerTag({
   // leave and come back rather than opening under it.
   let settling = false;
   let gone = false;
-
-  const fresh = () => readyNow(ready, now());
+  // The last time the app's window was in front. Only what started waiting
+  // after it is counted (w-93b3a1a796).
+  let lookedAt = Number(config.cornerTagLookedAt) || 0;
+  // Anything handed over without the moment it started waiting is dated from
+  // when this file first saw it, rather than counted new forever.
+  const firstSeen = new Map();
+  // Threads crossed off the tray, and when (shared/corner-tag.mjs,
+  // notDismissed). Kept across a restart, forgotten once a thread leaves the list.
+  let dismissed = { ...(config.cornerTagDismissed ?? {}) };
+  const toldNow = () => { try { return told() ?? []; } catch { return []; } };
+
+  const fresh = () => readyNow(notDismissed(newSince(ready, lookedAt, toldNow()), dismissed), now());
   const areas = () => screen.getAllDisplays().map((d) => d.workArea);
   const areaOf = (r) => screen.getDisplayMatching({ x: Math.round(r.x), y: Math.round(r.y), width: Math.max(1, Math.round(r.width)), height: Math.max(1, Math.round(r.height)) }).workArea;
+  // THE CLEAR BAND. The tag's window is the glass plus a few points of nothing
+  // on every side, so the resize arrows can hang over its corners the way a
+  // window's own do. Everything that places the window therefore works against
+  // a screen grown by that band, which puts the GLASS where the gap from the
+  // edge is measured to, and the list is placed against the glass rather than
+  // the window. A click in the band is not the tag's: the page says so and the
+  // window lets it through (corner-tag:clickable).
+  let frame = 0;
+  const framed = (a) => (frame ? { x: a.x - frame, y: a.y - frame, width: a.width + 2 * frame, height: a.height + 2 * frame } : a);
+  // Where she may park it: the screen, plus the band, plus the slack that lets
+  // her tuck it past the edge (shared/corner-tag.mjs, EDGE_SLACK).
+  const parkable = (a) => {
+    const f = framed(a);
+    return { x: f.x - EDGE_SLACK, y: f.y - EDGE_SLACK, width: f.width + 2 * EDGE_SLACK, height: f.height + 2 * EDGE_SLACK };
+  };
+  // WHERE THE GLASS IS DRAWN INSIDE THAT WINDOW, as the page measured it. It
+  // used to be worked out from the band alone, which is only the truth while
+  // the window is exactly the size the page asked for — and a grip drag widens
+  // the window first and lets the page catch up, so the last guess of a drag
+  // can outlive it. The list then lined up with a window edge that was no
+  // longer the glass's: "it is a little too far to the right... it's just the
+  // right sides that seem to be improperly aligned" (2026-10-13).
+  let inset = null;
+  const glassOf = (r) => {
+    if (inset) return { x: r.x + inset.x, y: r.y + inset.y, width: inset.width, height: inset.height };
+    return frame ? { x: r.x + frame, y: r.y + frame, width: r.width - 2 * frame, height: r.height - 2 * frame } : r;
+  };
   const inApp = () => {
     try { return !!mainWindow && !mainWindow.isDestroyed() && mainWindow.isFocused(); } catch { return false; }
   };
   const alive = (part) => !!wins[part] && !wins[part].isDestroyed();
   const rounded = (r) => ({ x: Math.round(r.x), y: Math.round(r.y), width: Math.round(r.width), height: Math.round(r.height) });
   const send = (part, channel, payload) => { if (alive(part) && loaded[part]) wins[part].webContents.send(channel, payload); };
+  // Back to 100%, then measure: a zoomed page drew the tag smaller than the
+  // size it reported, and the glass stood out past it (w-93b3a1a796). Its own
+  // zoom only; the app's window keeps whatever zoom it has.
+  const atFull = (part) => { try { if (alive(part)) wins[part].webContents.setZoomFactor?.(1); } catch { /* measured in points anyway */ } };
+  const remeasure = (part) => { atFull(part); send(part, 'corner-tag:measure'); };
+  // How big the tag draws, from the width of the screen it is resting on. The
+  // page multiplies everything by it, reports the size it came out, and this
+  // file places that. A tag dragged to another screen is measured again there.
+  // ...and how much bigger or smaller than that she has dragged it to be.
+  let zoom = tagZoom(config.cornerTagZoom);
+  const scaleNow = () => tagScaleOn((tag ? areaOf(tag) : areas()[0] ?? { width: 0 }).width, zoom);
   const sendState = () => {
-    const s = { ready: fresh(), working, now: now(), open };
+    const shown = fresh();
+    const s = { ready: shown, before: Math.max(0, ready.length - shown.length), working, now: now(), open, scale: scaleNow(), glass: !!glass };
     send('tag', 'corner-tag:state', s);
     send('card', 'corner-tag:state', s);
   };
   const shouldShow = () => tagShows({
-    on: config.cornerTag, hiddenUntil: config.cornerTagHiddenUntil ?? 0, now: now(), inApp: inApp(), ready: fresh().length, working,
+    on: config.cornerTag, hiddenUntil: config.cornerTagHiddenUntil ?? 0, now: now(), inApp: inApp(), ready: fresh().length,
   });
   // The list may only appear beside a tag that is on screen and should be.
   // A click that was on its way while the tag hid must not open it alone.
   const tagUp = () => !gone && alive('tag') && wins.tag.isVisible() && shouldShow();
 
+  // WHICH SCREEN IT BELONGS TO, AND WHERE ON IT. The corner it was parked in
+  // and the gap from that corner are what is remembered (shared/corner-tag.mjs,
+  // cornerPlace), because a point on the whole desktop stops meaning anything
+  // the moment a monitor is plugged in or taken away: every screen's
+  // coordinates move underneath it and the tag jumps.
+  let place = config.cornerTagPlace ?? null;
+  const screenFor = () => {
+    const known = tag ?? (config.cornerTagSpot ? { ...config.cornerTagSpot, ...tagSize } : null);
+    return known ? areaOf(known) : areas()[0];
+  };
+  // While a corner is held, the tag is placed from the corner opposite it
+  // rather than from its own last position, so the end she is not dragging
+  // does not creep across the screen as the size changes.
+  const resizeTo = (size) => {
+    if (!press?.grip || !tag) return;
+    tagSize = { width: Math.max(1, Math.round(size.width)), height: Math.max(1, Math.round(size.height)) };
+    const a = press.anchor;
+    tag = {
+      x: press.corner.endsWith('r') ? a.x : a.x - tagSize.width,
+      y: press.corner.startsWith('b') ? a.y : a.y - tagSize.height,
+      ...tagSize,
+    };
+    if (alive('tag')) wins.tag.setBounds(rounded(tag));
+  };
+
   const placeTag = () => {
-    const spot = restingSpot(tag ? { x: tag.x, y: tag.y } : config.cornerTagSpot ?? null, tagSize, areas());
+    const held = place ? spotFor(place, tagSize, framed(screenFor())) : null;
+    // A tag that has never been put anywhere starts its margin in from the
+    // screen's own edge; one she has parked may keep the slack she left it in.
+    const soFar = tag ? { x: tag.x, y: tag.y } : config.cornerTagSpot ?? null;
+    const spot = held ?? restingSpot(soFar, tagSize, areas().map(soFar ? parkable : framed));
     tag = { ...spot, ...tagSize };
     if (alive('tag')) wins.tag.setBounds(rounded(tag));
   };
 
   const placeCard = () => {
     if (!tag || !cardSize || !alive('card')) return;
-    wins.card.setBounds(rounded(cardPlacement(tag, cardSize, areaOf(tag)).card));
+    wins.card.setBounds(rounded(cardPlacement(glassOf(tag), cardSize, areaOf(tag)).card));
+  };
+
+  /* ------------------------- the Mac's own glass ------------------------- */
+  // Where each page draws its glass, and how round, as it last said. The Mac's
+  // glass is put exactly there, and the page draws no fill of its own.
+  const shape = { tag: null, card: null };
+  // Which way the tag's glass went over what is behind it. Only the tag is
+  // read: glass the list's size follows the Mac's own dark or light setting
+  // rather than the screen, so the list is held to the tag's reading.
+  let tone = null;
+  const toneSent = { tag: null, card: null };
+  let toneTimer = null;
+  const shareTone = () => {
+    for (const part of ['tag', 'card']) {
+      if (!tone || !alive(part) || !loaded[part] || toneSent[part] === tone) continue;
+      toneSent[part] = tone;
+      send(part, 'corner-tag:tone', tone);
+    }
+  };
+  const readTone = () => {
+    if (!glass || !shape.tag || !alive('tag') || !wins.tag.isVisible()) return;
+    let read = null;
+    try { read = glass.tone(wins.tag); } catch { /* no reading, keep the last */ }
+    if ((read !== 'light' && read !== 'dark') || read === tone) return;
+    tone = read;
+    dress('card');
+    shareTone();
+  };
+  const stopTones = () => { if (toneTimer) { clearTimer(toneTimer); toneTimer = null; } };
+  const watchTones = () => {
+    if (!glass || toneTimer || gone) return;
+    let measuredAt = now();
+    const tick = () => {
+      toneTimer = null;
+      if (gone || !alive('tag') || !wins.tag.isVisible()) return;
+      readTone();
+      if (now() - measuredAt >= MEASURE_EVERY_MS) {
+        measuredAt = now();
+        remeasure('tag');
+      }
+      toneTimer = setTimer(tick, TONE_EVERY_MS);
+    };
+    toneTimer = setTimer(tick, TONE_EVERY_MS);
+  };
+  const dress = (part) => {
+    if (!glass || !shape[part] || !alive(part)) return;
+    // The tag is clear glass, so a light page shows through it the way a dark
+    // one does; the regular glass frosts over light pages. The list keeps the
+    // regular glass, because it is read.
+    const opts = part === 'tag' ? { radius: shape.tag.radius, style: 'clear' }
+      : tone ? { radius: shape.card.radius, tone } : { radius: shape.card.radius };
+    try { glass.set(wins[part], shape[part].rect, opts); } catch { return; }
+    if (part === 'tag') { readTone(); watchTones(); }
   };
 
   const make = (part) => {
@@ -149,6 +296,7 @@ export function createCornerTag({
     win.setAlwaysOnTop(true, 'floating');
     try { win.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true, skipTransformProcessType: true }); } catch {}
     win.on('closed', () => { wins[part] = null; loaded[part] = false; });
+    win.webContents.on('did-finish-load', () => atFull(part));
     // A reload starts the handshake again: the window goes, anything half
     // done with it is let go, and until the page says it is ready nothing is
     // sent to it and it is not shown. The first load is not a reload.
@@ -156,6 +304,7 @@ export function createCornerTag({
       if (!loaded[part]) return;
       loaded[part] = false;
       hovered[part] = false;
+      toneSent[part] = null;
       if (part === 'tag') { endPress(true); if (win.isVisible()) win.hide(); }
       closeCard();
     });
@@ -176,7 +325,11 @@ export function createCornerTag({
   }
 
   const showCard = () => {
-    if (open && tagUp() && loaded.card && cardSize && alive('card') && !wins.card.isVisible()) wins.card.showInactive();
+    if (open && tagUp() && loaded.card && cardSize && alive('card') && !wins.card.isVisible()) {
+      wins.card.showInactive();
+      remeasure('card');
+      readTone();
+    }
   };
 
   function openCard() {
@@ -257,6 +410,35 @@ export function createCornerTag({
       closeCard();
       send('tag', 'corner-tag:dragging', true);
     }
+    // THE GRIP: the cursor sets the height, the page redraws everything from
+    // it, and what is remembered is how much bigger or smaller than this
+    // screen's automatic size that is.
+    if (press.grip) {
+      if (!press.moved) return;
+      const want = zoomFor(heightFromDrag(press.corner, press.fromHeight, dx, dy), areaOf(tag).width);
+      if (want === zoom) return;
+      const grew = want > zoom;
+      zoom = want;
+      sendState();
+      // THE WINDOW GROWS BEFORE THE PAGE DOES, never after. The page redraws
+      // at the new size and then reports it, a frame later; until that report
+      // the window is still the old rectangle, and a tag drawn larger than its
+      // window is a tag with its corners cut off, which is what she saw. So a
+      // growing drag widens the window on this side of the message straight
+      // away, by the same proportion, and the page's own measurement corrects
+      // it a frame later. Shrinking waits for the page: a window smaller than
+      // what is drawn in it clips, a window larger than it never does.
+      if (grew) {
+        // The glass the page is about to draw is the scale it was just handed
+        // (28 points times it), and everything in it grows together, so the
+        // width goes up by the same proportion until the page says otherwise.
+        // The window is that glass plus the band on every side.
+        const was = { w: Math.max(1, tagSize.width - 2 * frame), h: Math.max(1, tagSize.height - 2 * frame) };
+        const h = Math.ceil(28 * scaleNow());
+        resizeTo({ width: Math.ceil(was.w * h / was.h) + 2 * frame, height: h + 2 * frame });
+      }
+      return;
+    }
     if (press.moved && alive('tag')) {
       tag = { ...tag, x: press.from.x + dx, y: press.from.y + dy };
       wins.tag.setPosition(Math.round(tag.x), Math.round(tag.y));
@@ -280,11 +462,31 @@ export function createCornerTag({
     const p = press;
     if (!cancelled) follow();
     press = null;
+    if (p.grip) {
+      // The pointer is still on the tag, so the list waits for it to leave and
+      // come back, exactly as it does after a move. A press on a grip that
+      // never moved is not a click either: it does not open the app.
+      send('tag', 'corner-tag:dragging', false);
+      if (!p.moved) return;
+      // It has been dragged into a corner of its screen; let it settle back
+      // against the edge it is parked at, and remember where that is.
+      tag = { ...restingSpot({ x: tag.x, y: tag.y }, tagSize, areas().map(parkable)), ...tagSize };
+      if (alive('tag')) wins.tag.setBounds(rounded(tag));
+      place = cornerPlace(tag, framed(areaOf(tag)));
+      saveConfig(config, { cornerTagZoom: zoom, cornerTagSpot: { x: Math.round(tag.x), y: Math.round(tag.y) }, cornerTagPlace: place });
+      if (open) placeCard();
+      return;
+    }
     if (p.moved) {
-      tag = { ...restingSpot({ x: tag.x, y: tag.y }, tagSize, areas()), ...tagSize };
+      tag = { ...restingSpot({ x: tag.x, y: tag.y }, tagSize, areas().map(parkable)), ...tagSize };
       if (alive('tag')) wins.tag.setBounds(rounded(tag));
-      saveConfig(config, { cornerTagSpot: { x: Math.round(tag.x), y: Math.round(tag.y) } });
+      // Where she left it, said as a corner and a gap so it means the same
+      // thing on whatever screen it is on next.
+      place = cornerPlace(tag, framed(areaOf(tag)));
+      saveConfig(config, { cornerTagSpot: { x: Math.round(tag.x), y: Math.round(tag.y) }, cornerTagPlace: place });
       send('tag', 'corner-tag:dragging', false);
+      // Dragged onto another screen, it draws at that screen's size.
+      sendState();
     } else if (!cancelled) {
       cancelOpen();
       goTo(null);
@@ -310,13 +512,21 @@ export function createCornerTag({
     // A hide comes back by itself the moment it runs out.
     if (until > now()) wake = setTimer(refresh, until - now() + 50);
     if (!shouldShow()) {
+      stopTones();
       if (alive('tag') && wins.tag.isVisible()) { wins.tag.hide(); reset(); }
       else if (open) closeCard();
       return;
     }
     if (!alive('tag')) { make('tag'); return; }
     sendState();
-    if (loaded.tag && !wins.tag.isVisible()) wins.tag.showInactive();
+    if (loaded.tag && !wins.tag.isVisible()) {
+      wins.tag.showInactive();
+      // A page that redrew while hidden may never have said its new size, and
+      // the glass only moves when it does.
+      remeasure('tag');
+      readTone();
+      watchTones();
+    }
   }
 
   const bringAppForward = () => {
@@ -339,6 +549,7 @@ export function createCornerTag({
     const until = hiddenUntil(choice, now());
     if (!until) return;
     saveConfig(config, { cornerTagHiddenUntil: until });
+    count('tag_hidden', { seconds: Math.round((until - now()) / 1000) });
     refresh();
   };
 
@@ -351,8 +562,20 @@ export function createCornerTag({
 
   /* ------------------------------ from the app's page ---------------------- */
   ipcMain.handle('zero:corner-tag', (_e, state) => {
-    ready = Array.isArray(state?.ready) ? state.ready : [];
+    const given = Array.isArray(state?.ready) ? state.ready : [];
+    const ids = new Set(given.map((r) => r.id));
+    for (const id of firstSeen.keys()) if (!ids.has(id)) firstSeen.delete(id);
+    ready = given.map((r) => {
+      if (Number.isFinite(r.since)) return r;
+      if (!firstSeen.has(r.id)) firstSeen.set(r.id, now());
+      return { ...r, since: firstSeen.get(r.id) };
+    });
     working = Number.isFinite(state?.working) ? state.working : 0;
+    const kept = Object.fromEntries(Object.entries(dismissed).filter(([id]) => ids.has(id)));
+    if (Object.keys(kept).length !== Object.keys(dismissed).length) {
+      dismissed = kept;
+      try { saveConfig(config, { cornerTagDismissed: dismissed }); } catch { /* kept for this run only */ }
+    }
     refresh();
     return null;
   });
@@ -362,6 +585,7 @@ export function createCornerTag({
     const part = partOf(p);
     loaded[part] = true;
     sendState();
+    shareTone();
     if (part === 'tag') refresh();
     else if (open) { placeCard(); showCard(); }
     return null;
@@ -370,17 +594,37 @@ export function createCornerTag({
   ipcMain.handle('corner-tag:size', (_e, p) => {
     if (!p || !(p.width > 0) || !(p.height > 0)) return null;
     const size = { width: Math.ceil(p.width), height: Math.ceil(p.height) };
+    const radius = (rect) => (Number.isFinite(p.radius) && p.radius >= 0 ? p.radius : rect.height / 2);
     if (partOf(p) === 'card') {
       cardSize = size;
+      const rect = { x: 0, y: 0, ...size };
+      shape.card = { rect, radius: radius(rect) };
+      dress('card');
       if (open) { placeCard(); showCard(); }
       return null;
     }
+    if (p.glass && Number.isFinite(p.glass.x) && p.glass.width > 0) {
+      inset = {
+        x: Math.max(0, Math.round(p.glass.x)), y: Math.max(0, Math.round(p.glass.y)),
+        width: Math.round(p.glass.width), height: Math.round(p.glass.height),
+      };
+      frame = inset.x;
+    } else {
+      // Never the last rectangle: it belongs to a size the tag no longer is.
+      inset = null;
+    }
+    const rect = inset ?? glassOf({ x: 0, y: 0, ...size });
+    shape.tag = { rect, radius: radius(rect) };
+    dress('tag');
+    // Mid-resize the page's own measurement is the truth: it places the tag
+    // from the corner she is not holding.
+    if (press?.grip) { resizeTo(size); if (open) placeCard(); return null; }
     tagSize = size;
     // Nothing moves under the pointer while it is dragging.
     if (press?.moved) return null;
     // The first measure places it where she left it. Every one after keeps
     // the edge nearest its corner still as the words change length.
-    tag = tag && measured ? keepCorner(tag, tagSize, areaOf(tag)) : null;
+    tag = tag && measured ? keepCorner(tag, tagSize, framed(areaOf(tag))) : null;
     measured = true;
     placeTag();
     if (open) placeCard();
@@ -411,21 +655,87 @@ export function createCornerTag({
   ipcMain.handle('corner-tag:press', (_e, at) => {
     const pt = Number.isFinite(at?.x) && Number.isFinite(at?.y) ? { x: at.x, y: at.y } : screen.getCursorScreenPoint?.();
     if (!pt || !tag || !tagUp() || press) return null;
-    press = { start: pt, from: { x: tag.x, y: tag.y }, moved: false, at: now(), timer: null };
+    const corner = GRIPS.includes(at?.corner) ? at.corner : 'br';
+    press = {
+      start: pt, from: { x: tag.x, y: tag.y }, moved: false, at: now(), timer: null,
+      // A press on a grip resizes instead of moving: the corner she has hold
+      // of follows the cursor, and the one opposite it stays exactly where it
+      // is, the way a window resizes.
+      // THE GLASS, NOT THE WINDOW. The window is the glass plus the band on
+      // every side; measuring the window here asked for the band's height
+      // again on the first pull of the cursor, and the tag leapt (she met it
+      // in the running app: "it jumps to about three times its size").
+      grip: !!at?.grip, corner, fromHeight: Math.max(1, tagSize.height - 2 * frame),
+      anchor: {
+        x: corner.endsWith('r') ? tag.x : tag.x + tag.width,
+        y: corner.startsWith('b') ? tag.y : tag.y + tag.height,
+      },
+    };
     press.timer = setTimer(step, FRAME_MS);
     return null;
   });
   ipcMain.handle('corner-tag:release', (_e, p) => { endPress(!!p?.cancelled); return null; });
 
   ipcMain.handle('corner-tag:go', (_e, id) => { goTo(id); return null; });
+  // The X on a line of the list: off the tray, and only the tray.
+  ipcMain.handle('corner-tag:dismiss', (_e, id) => {
+    if (typeof id !== 'string' || !fresh().some((r) => r.id === id)) return null;
+    dismissed = { ...dismissed, [id]: now() };
+    try { saveConfig(config, { cornerTagDismissed: dismissed }); } catch { /* kept for this run only */ }
+    refresh();
+    return null;
+  });
   ipcMain.handle('corner-tag:hide', (_e, choice) => { hide(choice); return null; });
   ipcMain.handle('corner-tag:settings', () => { openSettings(); return null; });
 
   // A right-click on the tag offers the same choices as the list does.
+  // One place sets the size, whether it came from the grip or from the menu:
+  // the page is told, it redraws and reports what it came out, and that is
+  // what gets placed.
+  const setZoom = (next) => {
+    zoom = tagZoom(next);
+    saveConfig(config, { cornerTagZoom: zoom });
+    sendState();
+  };
+
+  // WHAT IS UNDER THE POINTER IN THE CLEAR BAND IS NOT THE TAG. The window is
+  // bigger than the glass now, so every click in that band would otherwise be
+  // swallowed by a transparent window floating over somebody's work — the
+  // exact fault that took the first drawn shadow out. The page watches the
+  // pointer (it keeps getting moves either way, because the window forwards
+  // them) and says when the thing under it is the glass or one of its corner
+  // arrows; the rest of the time the click goes straight through.
+  //
+  // It is never switched while a press is live: a press that began on the tag
+  // ends on the tag, wherever the cursor has got to.
+  let clickable = null;
+  const letClicksThrough = (on) => {
+    if (!alive('tag') || press) return;
+    if (clickable === on) return;
+    clickable = on;
+    try { wins.tag.setIgnoreMouseEvents?.(!on, { forward: true }); } catch { /* an older Electron: the band stays clickable */ }
+  };
+  ipcMain.handle('corner-tag:clickable', (_e, p) => { letClicksThrough(!!p?.on); return null; });
+
+  // A notch bigger or smaller, from the list's foot. The list stays open and
+  // is placed again as the tag changes size, because the whole point of
+  // sizing it from there is watching the tag while you do it.
+  ipcMain.handle('corner-tag:resize', (_e, p) => {
+    const by = Number(p?.by) < 0 ? -1 : 1;
+    setZoom(zoomStep(zoom, by));
+    return null;
+  });
+
   ipcMain.handle('corner-tag:menu', () => {
     if (!alive('tag')) return null;
     closeCard();
     Menu.buildFromTemplate([
+      // Dragging the grip is the way most people will find; this is the way
+      // somebody looks second, and the only way back to the automatic size.
+      { label: 'Bigger', click: () => setZoom(zoomStep(zoom, 1)) },
+      { label: 'Smaller', click: () => setZoom(zoomStep(zoom, -1)) },
+      { label: 'Size for this screen', enabled: zoom !== 1, click: () => setZoom(1) },
+      { type: 'separator' },
       ...HIDE_CHOICES.map((c) => ({ label: HIDE_LABELS[c.key], click: () => hide(c.key) })),
       { type: 'separator' },
       { label: 'Turn off in Settings…', click: openSettings },
@@ -436,17 +746,27 @@ export function createCornerTag({
   /* ------------------------------ from the system -------------------------- */
   // A screen that comes, goes or changes shape: the list shuts and the tag is
   // pulled back onto a screen if it was left hanging off one.
+  // A monitor plugged in or taken away: back to the corner it was parked in,
+  // the same gap in, on whichever screen now holds it. It used to be clamped
+  // from its old desktop point, which is what made it jump.
   const reseat = () => {
     if (gone) return;
     closeCard();
     if (!tag || press) return;
-    tag = { ...restingSpot({ x: tag.x, y: tag.y }, tagSize, areas()), ...tagSize };
-    if (alive('tag')) wins.tag.setBounds(rounded(tag));
+    placeTag();
+    sendState();
   };
   // After sleep the screens may have changed and a hide may have run out.
   const woke = () => { reseat(); refresh(); };
 
-  const onFocus = () => refresh();
+  // Being in the app is looking at everything it holds. The moment you leave
+  // is kept, so a restart does not count it all again.
+  const onFocus = () => { lookedAt = now(); refresh(); };
+  const onBlur = () => {
+    lookedAt = now();
+    try { saveConfig(config, { cornerTagLookedAt: lookedAt }); } catch { /* kept for this run only */ }
+    refresh();
+  };
   // The app's window is gone, and the tag goes with it. Left behind, it would
   // hold the app open with nothing behind it and nothing it could open.
   const dispose = () => {
@@ -456,6 +776,7 @@ export function createCornerTag({
     cancelClose();
     if (wake) { clearTimer(wake); wake = null; }
     if (watching) { clearTimer(watching); watching = null; }
+    stopTones();
     cancelOpen();
     for (const part of ['tag', 'card']) if (alive(part)) wins[part].destroy();
     for (const ch of CHANNELS) { try { ipcMain.removeHandler?.(ch); } catch {} }
@@ -470,7 +791,7 @@ export function createCornerTag({
 
   if (mainWindow) {
     mainWindow.on('focus', onFocus);
-    mainWindow.on('blur', onFocus);
+    mainWindow.on('blur', onBlur);
     mainWindow.on('closed', dispose);
   }
   try {

package/main/dev-window.mjs

@@ -8,7 +8,7 @@
 // The change that hurts is one to App.tsx that adds, removes or moves a
 // hook, which is what a branch switch does to it. React Fast Refresh keeps a
 // component's state only while its hooks match, so App is rebuilt from nothing:
-// `snap` is null again, App.tsx draws `<div className="boot">the app</div>`, and
+// `snap` is null again, App.tsx draws its boot screen (`<Booting />`), and
 // every child of App is thrown away and remade. The window drops back to the
 // loading page, and an open artifact closes and reopens. The
 // page never navigates, which is why nothing in the dev server's log looked bad