agentbox-app 0.1.13 → 0.1.16

package/shared/codex-usage.mjs

@@ -125,6 +125,7 @@ export function windowSpan(minutes) {
  */
 export function codexLimits(snapshot) {
   const out = [];
+  const refused = reachedWindow(snapshot);
   for (const key of WINDOWS) {
     const window = snapshot?.[key];
     if (!plain(window)) continue;
@@ -133,11 +134,18 @@ export function codexLimits(snapshot) {
     const minutes = field(window, 'windowDurationMins', 'window_minutes');
     const [span, name] = windowSpan(minutes) ?? FALLBACK[key];
     const resets = field(window, 'resetsAt', 'resets_at');
+    const reached = refused === key;
     out.push({
       span,
       qualifier: null,
       name,
-      percent: Math.max(0, Math.min(100, Math.round(percent))),
+      percent: drawnPercent(percent),
+      // WHETHER THIS WINDOW IS ACTUALLY FINISHED, which a percentage cannot say
+      // (w-36c51443df). Only the provider knows: a window can be refused below
+      // a hundred by a spend control or a per-account limit, and one sitting at
+      // a hundred may still be serving. So this is read off the payload and
+      // never derived from `percent`.
+      reached,
       resetsText: null,
       resetsOn: null,
       resetsAt: resets === null ? null : resets * 1000,
@@ -147,6 +155,78 @@ export function codexLimits(snapshot) {
   return out;
 }
 
+/**
+ * WHICH WINDOW THE PROVIDER SAYS IS SPENT, or null when it says nothing.
+ *
+ * `rateLimitReachedType` NAMES a window (`primary` / `secondary`), measured on a
+ * live push 2026-10-09, so it belongs on that window's own line rather than on
+ * the reading as a whole. A name for a window that is not in the payload is
+ * ignored rather than guessed at: marking a line we were not told about is how
+ * a confident wrong number gets drawn.
+ */
+function reachedWindow(snapshot) {
+  const named = snapshot?.rateLimitReachedType ?? snapshot?.rate_limit_reached_type;
+  return WINDOWS.includes(named) ? named : null;
+}
+
+/**
+ * THE FIGURE TO DRAW, WHICH MAY NOT MANUFACTURE A HUNDRED (w-36c51443df).
+ *
+ * `Math.round` drew 99.6% as "100%", so the one number on the screen that
+ * should have meant "stop" meant "nearly". A reading nobody can act on is worse
+ * than a blunter one, so anything short of the whole window draws at most 99
+ * and 100 means a hundred.
+ *
+ * AND `reached` IS DELIBERATELY NOT AN INPUT HERE. The first draft of this fix
+ * forced 100 whenever the provider refused the window, which is the same sin
+ * one field along: a window capped at 12% by a spend control really is at 12%,
+ * and writing 100 over it would be inventing usage that was never reported.
+ * `percent` says how much has been spent; `reached` says whether it is refused.
+ * Two facts, two fields, and the panel reads "stop" off the second one.
+ *
+ * The clamp stays exactly as it was: a provider that over- or under-reports
+ * must not put an impossible number on her screen.
+ */
+function drawnPercent(percent) {
+  const inRange = Math.max(0, Math.min(100, percent));
+  if (inRange >= 100) return 100;
+  return Math.min(99, Math.round(inRange));
+}
+
+/**
+ * THE FACTS ABOUT THE ACCOUNT RATHER THAN ABOUT ONE WINDOW (w-36c51443df).
+ *
+ * The push carries ten fields and `codexLimits` read two of them. These four
+ * are the rest of what a person would want to know, and the campaign that found
+ * this could not answer any of them from the screen:
+ *
+ *   plan                which subscription is paying. Measured: "prolite".
+ *   credits             whether there is anything behind the window when it
+ *                       goes. Measured: `{hasCredits:false, balance:"0"}`, so
+ *                       nothing -- and "100% used" reads very differently with
+ *                       and without that.
+ *   spendControlReached a cap she or her organisation set, not the plan's.
+ *   reached             which window the provider refused, for any surface
+ *                       drawing the reading whole rather than line by line.
+ *
+ * NULLS RATHER THAN GUESSES, for the reason main/codex-usage.mjs gives about
+ * percentages: a plan nobody has reported is not a plan of none, and a reading
+ * that invents one is worse than a panel that stays quiet.
+ */
+export function codexPlan(snapshot) {
+  const credits = plain(snapshot?.credits) ? snapshot.credits : null;
+  const bool = (value) => (typeof value === 'boolean' ? value : null);
+  return {
+    plan: typeof snapshot?.planType === 'string' && snapshot.planType
+      ? snapshot.planType
+      : (typeof snapshot?.plan_type === 'string' && snapshot.plan_type ? snapshot.plan_type : null),
+    credits: credits ? (bool(credits.hasCredits) ?? bool(credits.has_credits)) : null,
+    unlimitedCredits: credits ? bool(credits.unlimited) : null,
+    spendControlReached: bool(snapshot?.spendControlReached ?? snapshot?.spend_control_reached),
+    reached: reachedWindow(snapshot),
+  };
+}
+
 /**
  * FOLD A ROLLING UPDATE INTO WHAT WE ALREADY HAD, WHICH IS THE PROTOCOL'S OWN
  * INSTRUCTION AND NOT A KINDNESS.
@@ -155,7 +235,7 @@ export function codexLimits(snapshot) {
  * carrying only the five hour window would take the week away, and one carrying
  * neither would take both -- and this repo already puts exactly that on the wire
  * (`{ rateLimits: {} }`, in
- * tests/one-codex-process-carries-many-threads-and-a-card-nobody-answers-denies.test.mjs).
+ * tests/one-codex-process-carries-many-threads-and-a-card-nobody-answers-waits.test.mjs).
  * The failure would look like the corner going quiet for no reason, which is the
  * complaint this whole surface started from.
  *
@@ -168,6 +248,23 @@ export function codexLimits(snapshot) {
  * Only the two windows are carried. Nothing else in the payload is drawn, and a
  * merge that kept fields nobody reads would be inviting somebody to read them.
  */
+/**
+ * THE ACCOUNT-LEVEL FIELDS A FOLD ALSO HAS TO KEEP (w-36c51443df).
+ *
+ * The rule above was "only the two windows, because a merge that kept fields
+ * nobody reads would be inviting somebody to read them". That was right while
+ * nothing read them, and it is exactly why a cap was unreadable. `codexPlan`
+ * reads these now, so they have to survive a fold for the same reason the
+ * windows do: a push carrying only a window would otherwise drop a
+ * `rateLimitReachedType` that arrived a beat earlier, and the corner would fall
+ * back from "spent" to a percentage for no reason -- which is the failure this
+ * function exists to prevent, one field along.
+ *
+ * Still nothing beyond what is drawn. `limitId`, `limitName`, `normalModelSlug`
+ * and `individualLimit` stay out, because nothing reads them.
+ */
+const CARRIED = ['planType', 'credits', 'spendControlReached', 'rateLimitReachedType'];
+
 export function mergeRateLimits(previous, update) {
   const out = {};
   for (const key of WINDOWS) {
@@ -175,5 +272,14 @@ export function mergeRateLimits(previous, update) {
     else if (plain(previous?.[key])) out[key] = previous[key];
     else out[key] = null;
   }
+  // `undefined` AND `null` BOTH MEAN "THIS PUSH SAID NOTHING", so either keeps
+  // what was already known -- the measured push carried explicit nulls for
+  // `spendControlReached` and `rateLimitReachedType` while they were fine, and
+  // treating those as news would forget a cap on the very next beat. A push
+  // genuinely lifting one carries `false`, which is a value and does replace.
+  for (const key of CARRIED) {
+    const said = update?.[key];
+    out[key] = said === undefined || said === null ? (previous?.[key] ?? null) : said;
+  }
   return out;
 }

package/shared/corner-tag.d.mts

@@ -5,10 +5,32 @@
 export type HideChoice = { key: '5m' | '30m' | 'today'; label: string };
 export const HIDE_CHOICES: HideChoice[];
 
-export function tagSays(counts: { ready?: number; working?: number }): { kind: 'ready' | 'working'; text: string } | null;
+/** text is the count on the tag; label is what it says aloud ("2 waiting"). */
+export function tagSays(counts: { ready?: number }): { kind: 'ready'; text: string; label: string } | null;
 
 export type ReadyLine = { id: string; title: string; says: string; since?: number; open?: string | null };
 export function cardLines<T extends ReadyLine>(ready: T[], now: number, max?: number): {
   lines: (T & { waited: string })[];
   more: number;
 };
+
+/** The four corners that resize it, and the arrow each one draws. */
+export const GRIPS: readonly ['tl', 'tr', 'bl', 'br'];
+export type Grip = 'tl' | 'tr' | 'bl' | 'br';
+
+/** The nine dots, in whole pixels, for a tag this tall. */
+export const LATTICE: { box: number; dot: number; gap: number };
+export function latticeGrid(box: number, dpr?: number): {
+  dot: number; gap: number; pitch: number; side: number; size: number;
+  dots: { cx: number; cy: number }[];
+};
+
+/** How much of the tag's size the list takes; it is read, not glanced at. */
+export function cardScale(scale: number): number;
+
+type Rect = { x: number; y: number; width: number; height: number };
+/** A page's measurement of itself, in screen points at the zoom it is drawn at. */
+export function inPoints(
+  m: { width: number; height: number; glass?: Rect; radius?: number },
+  zoom?: number,
+): { width: number; height: number; glass?: Rect; radius?: number };

package/shared/corner-tag.mjs

@@ -1,11 +1,10 @@
 // THE CORNER TAG (w-dafae58a23): the rules, and nothing that touches a window.
 //
 // You lose track of agents once you are in another app, and the ones waiting on
-// you sit idle. The answer that survived eight rounds of drawings is a small tag
-// in a corner of the screen that says "2 ready for you" when an agent has
-// something for you and "20 working" when none does. Twenty agents running is
-// ordinary, so working agents are a count and never a list: only what is ready
-// for you is worth a line.
+// you sit idle. The answer is a small tag in a corner of the screen: the
+// nine-dot mark and how many started waiting since you last had the app in
+// front. When nothing is new it is gone (w-93b3a1a796), because a tag that is
+// always there is a tag nobody reads.
 //
 // It must never become a nag. So it hides for a while and comes back on its
 // own, there is no one-click way to make it gone for good (that becomes a thing
@@ -18,6 +17,17 @@
 /** Space between the tag and the edge of the screen when it rests in a corner. */
 export const MARGIN = 18;
 
+/**
+ * HOW FAR PAST THE EDGE SHE MAY PARK IT (2026-10-13). The resting rule used to
+ * hold the whole tag inside the screen, so a drag to the right stopped with
+ * the tag flush against the edge and sprang back from anything further: "I
+ * can't seem to put it further to the right. It snaps back into place in this
+ * slot but I often want it a little bit further to the right side of the
+ * screen." It may now hang this far off any edge — enough to tuck it away,
+ * never enough to lose it.
+ */
+export const EDGE_SLACK = 24;
+
 /** The ways to hide it. All of them come back; none of them is permanent. */
 export const HIDE_CHOICES = [
   { key: '5m', label: '5 min' },
@@ -37,37 +47,244 @@ export function hiddenUntil(choice, now) {
   return 0;
 }
 
-/** The words on the tag, or null when there is nothing to say. Short, because
- *  "22 ready for you" in the corner of a full screen was more than it needed;
- *  "waiting" was picked over "ready" and "need you". */
-export function tagSays({ ready = 0, working = 0 } = {}) {
-  if (ready > 0) return { kind: 'ready', text: `${ready} waiting` };
-  if (working > 0) return { kind: 'working', text: `${working} working` };
+/**
+ * What the tag says: the mark and how many are new, or null, in which case it
+ * is gone. A working count kept it on screen all day and made it wallpaper
+ * (w-93b3a1a796), so working agents only appear in its list. "Waiting" won
+ * over "ready" and "need you", and is what the tag says aloud.
+ */
+export function tagSays({ ready = 0 } = {}) {
+  if (ready > 0) return { kind: 'ready', text: String(ready), label: `${ready} waiting` };
   return null;
 }
 
 /**
- * What the tag counts and lists: everything waiting on you, newest first.
- * The first version put threads from weeks ago at the top of the list; the
- * second cut everything older than a day, and then a Needs you of 58 read
- * "3 waiting" in the corner (w-0961e5523b). So the count is the whole of it,
- * the same number the app shows, and only the order keeps the old ones out
- * of the way: the list shows the newest three and folds the rest into "and N
- * more". Something with no moment it became ready (an agent stopped on a
- * yes, right now) sorts as now.
+ * A page's measurement of itself, in screen points. A page drawn at a zoom
+ * other than 100% measures in its own units, and the window and the Mac's
+ * glass are placed in points: at 87% the glass stood out past the tag
+ * (w-93b3a1a796). A zoom it cannot read counts as 100%.
+ */
+export function inPoints({ width, height, glass, radius }, zoom) {
+  const z = Number.isFinite(zoom) && zoom > 0 ? zoom : 1;
+  return {
+    width: width * z,
+    height: height * z,
+    glass: glass && { x: glass.x * z, y: glass.y * z, width: glass.width * z, height: glass.height * z },
+    radius: Number.isFinite(radius) ? radius * z : radius,
+  };
+}
+
+/**
+ * What started waiting after you last looked, which is the last time the
+ * app's window was in front, and whatever a notification told you about since
+ * you were last at the app (`told`, { id, at }), dated from when it told you.
+ * Before you have ever looked, everything counts.
+ */
+export function newSince(ready, lookedAt, told = []) {
+  const toldAt = new Map();
+  for (const t of told ?? []) if (t?.id != null) toldAt.set(t.id, Number.isFinite(t.at) ? t.at : 0);
+  const out = [];
+  for (const r of ready ?? []) {
+    const own = Number.isFinite(r.since) ? r.since : null;
+    if (toldAt.has(r.id)) out.push(own != null && own >= toldAt.get(r.id) ? r : { ...r, since: toldAt.get(r.id) });
+    else if (!(lookedAt > 0) || (own != null && own > lookedAt)) out.push(r);
+  }
+  return out;
+}
+
+/**
+ * What is left once you have crossed some off the tray (`dismissed`, id to
+ * when). A thread stays off until it has something newer than that.
+ */
+export function notDismissed(list, dismissed = {}) {
+  return (list ?? []).filter((r) => {
+    const at = dismissed?.[r.id];
+    return !(Number.isFinite(at) && !(r.since > at));
+  });
+}
+
+/**
+ * HOW BIG THE TAG DRAWS, from the width of the screen it rests on (2026-10-13).
+ * One number: the page multiplies everything in the tag and its list by it, so
+ * the words, the chevron, the nine-dot mark and the padding grow together.
+ *
+ * She reads the tray on a 32" screen and on a laptop, and 28px was too small on
+ * both, worst on the big one: "a little bigger... esp on my 32 inch screen but
+ * also maybe on smaller screens too". So it is a ladder off the screen's own
+ * width in points, not one size for everything and not a setting to find.
+ *
+ * The first ladder climbed too gently — "34 px on a 32-inch screen is still far
+ * too small so you need to scale it more with screen size" — so the steps are
+ * now 31px on a laptop, 36px, 42px, and 48px on a screen as wide as hers
+ * (3413 points). 1 would be the old 28px tag, which nothing asks for any more.
+ *
+ * THE STEPS ARE WHOLE PIXELS, and the scale is worked back from them. A tag
+ * 30.8px tall puts its bottom border on half a device pixel, where it goes
+ * soft and its bottom corners break up; she saw exactly that and called it
+ * messed up (2026-10-13). Whole heights keep every edge on a real pixel.
+ */
+export const TAG_BASE = 28;
+export const TAG_HEIGHTS = [
+  { from: 0, px: 31 },
+  { from: 1900, px: 36 },
+  { from: 2400, px: 42 },
+  { from: 3000, px: 48 },
+];
+
+/** How tall the tag draws on a screen this many points wide, in whole pixels. */
+export function tagHeight(width) {
+  const w = Number.isFinite(width) ? width : 0;
+  let px = TAG_HEIGHTS[0].px;
+  for (const step of TAG_HEIGHTS) if (w >= step.from) px = step.px;
+  return px;
+}
+
+/** The one number the page multiplies everything by. */
+export function tagScale(width) {
+  return tagHeight(width) / TAG_BASE;
+}
+
+/**
+ * HER OWN SIZE, KEPT AS A MULTIPLE OF THE AUTOMATIC ONE (2026-10-13). She
+ * asked to be able to resize the tray, by dragging a corner of it.
+ *
+ * What she sets is not a height in pixels but how much bigger or smaller than
+ * the automatic size she wants it, because the automatic size is the thing
+ * that knows about screens: a tag she grows by a fifth on her laptop is a
+ * fifth bigger on the 32" too, rather than shrinking back to a laptop's
+ * number the moment she plugs the big screen in.
+ */
+export const TAG_ZOOM = { min: 0.75, max: 2, step: 0.1 };
+/** However far she drags, the tag stays a tag. */
+export const TAG_LIMITS = { min: 24, max: 80 };
+
+/** Her multiple, kept sane; nothing stored means the automatic size. */
+export function tagZoom(zoom) {
+  const z = Number.isFinite(zoom) ? zoom : 1;
+  return clamp(Math.round(z * 100) / 100, TAG_ZOOM.min, TAG_ZOOM.max);
+}
+
+/** How tall the tag draws on this screen, with her multiple applied. */
+export function tagHeightOn(width, zoom) {
+  return clamp(Math.round(tagHeight(width) * tagZoom(zoom)), TAG_LIMITS.min, TAG_LIMITS.max);
+}
+
+/** The scale the page is handed: the automatic size times her multiple. */
+export function tagScaleOn(width, zoom) {
+  return tagHeightOn(width, zoom) / TAG_BASE;
+}
+
+/** The multiple a tag dragged to this height means, on this screen. */
+export function zoomFor(height, width) {
+  const h = clamp(Number.isFinite(height) ? height : 0, TAG_LIMITS.min, TAG_LIMITS.max);
+  return tagZoom(h / tagHeight(width));
+}
+
+/** One notch bigger or smaller, for the tag's own menu. */
+export function zoomStep(zoom, by) {
+  return tagZoom(tagZoom(zoom) + by * TAG_ZOOM.step);
+}
+
+/** Every corner resizes it, because one ledge in one corner was not findable. */
+export const GRIPS = ['tl', 'tr', 'bl', 'br'];
+
+/**
+ * How tall a drag on this corner means. The corner follows the cursor and the
+ * opposite one stays where it is, the way a window resizes. The tag is four
+ * times wider than it is tall, so sideways travel counts for about a third:
+ * the diagonal still feels like a diagonal without the width running away.
+ */
+export function heightFromDrag(corner, fromHeight, dx, dy) {
+  const down = corner.startsWith('b') ? dy : -dy;
+  const out = corner.endsWith('r') ? dx : -dx;
+  return Math.round(fromHeight + down + out * 0.35);
+}
+
+/**
+ * HOW MUCH OF THE TAG'S SIZE THE LIST TAKES (2026-10-13). The tag is a glance
+ * from across a desk and wants to be big on a big screen; the list is read a
+ * line at a time and does not. At the tag's full scale on her 32" the rows came
+ * out "really, really big... way bigger than anything else I'm used to seeing
+ * on the screen", so the list follows the tag less than a third of the way and
+ * stops at a quarter bigger than the app's own text.
+ */
+export function cardScale(scale) {
+  const s = Number.isFinite(scale) ? scale : 1;
+  return clamp(Math.round((1 + (s - 1) * 0.3) * 1000) / 1000, 1, 1.25);
+}
+
+/**
+ * THE NINE DOTS ARE ONE DRAWING, not nine boxes (2026-10-13).
+ *
+ * They were boxes in a grid, and twice the fix was to give the dot and the gap
+ * whole pixels. That only holds on a screen whose point is a whole device
+ * pixel. Hers is not: a Mac in a scaled mode draws 1.5 device pixels to the
+ * point, so a 3pt dot is 4.5 and a 1pt gap is 1.5, and the browser snaps every
+ * box on its own — 5,5,5 across with gaps of 2 and 1. Rasterised through the
+ * real page, 16 of 28 sizes came out uneven at that scale and none at 1x or
+ * 2x. "It's the same issue we've had six times before."
+ *
+ * An svg of nine circles on one pitch is rasterised in one go, so the spacing
+ * cannot round apart whatever the screen does, and the geometry can go back to
+ * the launch film's own: dots of 2.7 and gaps of 0.95 in a box of 10.
+ */
+export const LATTICE = { box: 10, dot: 2.7, gap: 0.95 };
+
+/**
+ * The mark for a box this many points across, on a screen drawing this many
+ * device pixels to the point.
+ *
+ * THE PITCH IS A WHOLE NUMBER OF DEVICE PIXELS. That is the whole trick. Every
+ * dot then sits at the same distance from a device-pixel boundary as every
+ * other, so all nine are rasterised identically and the spacing cannot round
+ * apart — however the mark's own corner happens to land. Whole POINTS were the
+ * old rule, and a point on her screen is 1.5 device pixels, which is why it
+ * kept coming back.
+ */
+export function latticeGrid(box, dpr = 1) {
+  const px = Number.isFinite(dpr) && dpr > 0 ? dpr : 1;
+  const want = (Number.isFinite(box) && box > 0 ? box : LATTICE.box) * px;
+  // Both whole numbers either side of the film's dot and gap, and the pair
+  // whose mark comes closest to the size asked for — a dot and a gap rounded
+  // on their own can leave the mark a fifth too big, which shows.
+  const ideal = { dot: (want * LATTICE.dot) / LATTICE.box, gap: (want * LATTICE.gap) / LATTICE.box };
+  const ways = [];
+  for (const dot of [Math.floor(ideal.dot), Math.ceil(ideal.dot)]) {
+    for (const gap of [Math.floor(ideal.gap), Math.ceil(ideal.gap)]) {
+      const d = Math.max(2, dot);
+      const g = Math.max(1, Math.min(gap, d - 1));
+      ways.push({ dot: d, gap: g, side: 3 * d + 2 * g });
+    }
+  }
+  // A dot five times its gap is a mark whose dots all but touch, and one twice
+  // its gap is a loose one; the film's is 2.84. Keep inside that band if any
+  // pair can, and among those take the closest size.
+  const inBand = ways.filter((w) => w.dot / w.gap >= 2 && w.dot / w.gap <= 4);
+  const pick = (inBand.length ? inBand : ways)
+    .sort((a, b) => Math.abs(a.side - want) - Math.abs(b.side - want)
+      || Math.abs(a.dot / a.gap - LATTICE.dot / LATTICE.gap) - Math.abs(b.dot / b.gap - LATTICE.dot / LATTICE.gap));
+  const { dot, gap, side } = pick[0];
+  const pitch = dot + gap;
+  const at = [0, 1, 2].map((i) => dot / 2 + i * pitch);
+  return { dot, gap, pitch, side, size: side / px, dots: at.flatMap((cy) => at.map((cx) => ({ cx, cy }))) };
+}
+
+/**
+ * Newest first. Something with no moment it became ready (an agent stopped on
+ * a yes, right now) sorts as now.
  */
 export function readyNow(ready, now) {
   return [...(ready ?? [])]
     .sort((a, b) => (Number.isFinite(b.since) ? b.since : now) - (Number.isFinite(a.since) ? a.since : now));
 }
 
-/** Whether the tag is on screen right now. */
-export function tagShows({ on, hiddenUntil: until = 0, now, inApp, ready = 0, working = 0 }) {
+/** Whether the tag is on screen right now; `ready` is how many are new. */
+export function tagShows({ on, hiddenUntil: until = 0, now, inApp, ready = 0 }) {
   if (on === false) return false;
   if (until > now) return false;
   // In the app itself the inbox already says all of this, bigger.
   if (inApp) return false;
-  return !!tagSays({ ready, working });
+  return !!tagSays({ ready });
 }
 
 /** How long something has waited, in units. */
@@ -117,6 +334,38 @@ function inLowerHalf(r, a) { return r.y + r.height / 2 > a.y + a.height / 2; }
  * corner stays put, so "2 ready for you" turning into "20 working" does not
  * walk the tag away from the edge you parked it against.
  */
+/**
+ * WHERE THE TAG IS PARKED, SAID IN A WAY THAT SURVIVES A CHANGE OF SCREEN
+ * (2026-10-13). Its spot used to be remembered as a point on the whole desktop,
+ * so plugging in a monitor, or unplugging one, moved every screen's
+ * coordinates underneath it and the tag "jumps around quite a bit". A corner
+ * and a gap mean the same thing on any screen: bottom right, 18 points in.
+ */
+export function cornerPlace(bounds, area) {
+  const right = inRightHalf(bounds, area);
+  const lower = inLowerHalf(bounds, area);
+  return {
+    corner: `${lower ? 'b' : 't'}${right ? 'r' : 'l'}`,
+    dx: Math.round(right ? area.x + area.width - (bounds.x + bounds.width) : bounds.x - area.x),
+    dy: Math.round(lower ? area.y + area.height - (bounds.y + bounds.height) : bounds.y - area.y),
+  };
+}
+
+/** That same place on this screen, wholly on it however small it is. */
+export function spotFor(place, size, area) {
+  if (!place?.corner) return null;
+  const right = place.corner.endsWith('r');
+  const lower = place.corner.startsWith('b');
+  // A gap may be negative: that is the tag tucked past the edge, which she
+  // asked for and which the resting rule now allows.
+  const dx = clamp(Number.isFinite(place.dx) ? place.dx : MARGIN, -EDGE_SLACK, Math.max(0, area.width - size.width));
+  const dy = clamp(Number.isFinite(place.dy) ? place.dy : MARGIN, -EDGE_SLACK, Math.max(0, area.height - size.height));
+  return {
+    x: right ? area.x + area.width - size.width - dx : area.x + dx,
+    y: lower ? area.y + area.height - size.height - dy : area.y + dy,
+  };
+}
+
 export function keepCorner(bounds, size, area) {
   const x = inRightHalf(bounds, area) ? bounds.x + bounds.width - size.width : bounds.x;
   const y = inLowerHalf(bounds, area) ? bounds.y + bounds.height - size.height : bounds.y;
@@ -128,14 +377,20 @@ export function keepCorner(bounds, size, area) {
  * screen, so it never runs off an edge, lined up with the tag's outer edge.
  */
 export function cardPlacement(tag, card, area, gap = 8) {
-  let above = inLowerHalf(tag, area);
   const alignRight = inRightHalf(tag, area);
   const x = clamp(alignRight ? tag.x + tag.width - card.width : tag.x, area.x, area.x + area.width - card.width);
-  const up = tag.y - gap - card.height;
-  const down = tag.y + tag.height + gap;
-  // A tall list near a short screen's middle may not fit the side it prefers.
-  if (above && up < area.y) above = false;
-  else if (!above && down + card.height > area.y + area.height) above = true;
-  const y = clamp(above ? up : down, area.y, area.y + area.height - card.height);
+  // Which side has the room. The list may never cover the tag: she adjusts the
+  // tray's size from this list ("you still need to see the component to be able
+  // to make those decisions"), and a list over the thing it is sizing is no
+  // use. So the side is picked by which has more room, the list is kept on
+  // that side of the tag, and only then is it brought onto the screen — a list
+  // taller than its side runs off the screen's edge rather than over the tag.
+  const room = { above: tag.y - area.y, below: area.y + area.height - (tag.y + tag.height) };
+  let above = inLowerHalf(tag, area);
+  if (above && room.above < card.height + gap && room.below > room.above) above = false;
+  else if (!above && room.below < card.height + gap && room.above > room.below) above = true;
+  const y = above
+    ? Math.min(tag.y - gap - card.height, Math.max(area.y, tag.y - gap - card.height))
+    : Math.max(tag.y + tag.height + gap, Math.min(area.y + area.height - card.height, tag.y + tag.height + gap));
   return { above, alignRight, card: { x, y, width: card.width, height: card.height } };
 }

package/shared/dead-run-trace.mjs

@@ -34,6 +34,20 @@ const NARRATED = /^\d{2}:\d{2}:\d{2}\s{2}\S/m;
 
 const EXITED = /^# exited \((-?\d+)\)/m;
 
+// Written after the exit line's time when the person stopped the run (Stop,
+// Z, closing or putting off the thread): that end is not a death to report.
+export const STOPPED_ON_REQUEST = ' · stopped on request';
+const STOPPED = /^# exited \([^)]*\) \S+ · stopped on request$/m;
+
+// A tool call, as every engine traces one: `HH:MM:SS  [Bash] ls`. Text lines
+// do not count, because the CLI types its own refusals as the agent's words,
+// and neither does OpenCode's `[error]`.
+const TOOL_LINE = /^\d{2}:\d{2}:\d{2}\s{2}\[(?!error\])[^\]\s]+\]/m;
+
+export function tracesAToolCall(text) {
+  return TOOL_LINE.test(String(text ?? ''));
+}
+
 // THE DIAGNOSIS IS ON THE SECOND LINE, NOT THE FIRST, and reading only the
 // prefixed line loses it entirely. What the tool prints arrives as one chunk
 // and is written with one `stderr: ` in front of the whole chunk, so a refusal
@@ -94,8 +108,9 @@ function errorResult(raw) {
 
 /**
  * @param {string} text the whole trace file
- * @returns {{everRan: boolean, exitCode: number|null, stderr: string}}
+ * @returns {{everRan: boolean, worked: boolean, exitCode: number|null, stoppedOnRequest: boolean, stderr: string}}
  *   `stderr` is what the tool said about itself, from either place it says it.
+ *   `worked` means the agent called at least one tool before it ended.
  *   `everRan` false means the CLI never produced a first line: the process
  *   started and died before it was a session. `exitCode` null means the trace
  *   has no exit line at all, which is what a run killed with the app looks
@@ -106,7 +121,9 @@ export function readDeadRunTrace(text) {
   const exited = EXITED.exec(raw);
   return {
     everRan: NARRATED.test(raw),
+    worked: tracesAToolCall(raw),
     exitCode: exited ? Number(exited[1]) : null,
+    stoppedOnRequest: STOPPED.test(raw),
     stderr: [stderrChunks(raw), errorResult(raw)].filter(Boolean).join('\n').slice(-1000),
   };
 }
@@ -122,6 +139,6 @@ export function readDeadRunTrace(text) {
  * the supervisor has no business speaking over it.
  */
 export function traceShowsASilentDeath(trace) {
-  if (!trace || trace.exitCode == null) return false;
+  if (!trace || trace.exitCode == null || trace.stoppedOnRequest) return false;
   return !trace.everRan || trace.exitCode !== 0;
 }