@litfamily/litclaude 1.0.23 → 1.0.25

package/plugins/litclaude/lib/mod/frame.mjs

@@ -7,7 +7,7 @@
 //   ╭─ [🔥 LIT] · lit-loop ─────────────────────────── WORK ● ─╮
 //   │ ● PLAN ━━ [WORK] ━━ ○ REVIEW              goal ██░░░ 2/5 │
 //   │ skills [⚡ lit-plan] [⚡ litresearch] [↯ lit-docx]        │
-//   ╰─ ctx 42% ▰▰▱▱▱ · 5h 31% · git main ──────────────────────╯
+//   ╰─ ctx 42% ▰▰▱▱▱ · 5h 31% · 1w 12% · git main ─────────────╯
 //
 // Each bracket pair stands for the two end cells of a filled pill: the brand on pink, the active
 // phase and this request's skills on the accent with dark text, skills from earlier requests on
@@ -44,7 +44,7 @@ export const PALETTE = Object.freeze({
 // The status line's level colours (xterm 71, 178, 167) and its empty bar cells (238).
 const HUD = Object.freeze({ green: "#5faf5f", yellow: "#d7af00", red: "#d75f5f", empty: "#444444" });
 // Past this many columns the card stops growing, so a wide terminal does not stretch it thin.
-export const CARD_MAX = 80;
+export const CARD_MAX = 120;
 // Pill colours: dark text on the bright fills, the muted pill for earlier skills and +N, the brand
 // pink of the status line's prefix, and the connectors between phases.
 const PILL = Object.freeze({ ink: "#0b0f14", muted: "#2d333b", mutedText: "#adb5bf", brand: PALETTE.pink, rail: "#46505c" });
@@ -145,25 +145,59 @@ const fitJoined = (segments, room) => {
 
 const joinSegments = (kept, joinerColor) => kept.flatMap((part, index) => (index > 0 ? [span(part.joiner, { fg: joinerColor }), ...part.spans] : part.spans));
 
+const COMET_TAIL = 12;
+
+// The comet's colour `k` of the way from its tail (0) to its head (1): flame orange fading in, pink
+// through the body and white at the head, laid over the rule's own colour.
+const cometColor = (base, k) => {
+  const hue = k > 0.8 ? lerpColor(PALETTE.pink, "#ffffff", (k - 0.8) / 0.2) : lerpColor(PALETTE.orange, PALETTE.pink, k / 0.8);
+  return lerpColor(base, hue, Math.min(1, k * 1.6));
+};
+
+// The rule of an edge, `count` cells from column `start`. With a comet ({ x, dir }: its head's
+// column and travel direction) the cells behind the head light up, brightest at the head, and the
+// rule becomes one span per cell; without one it stays a single span.
+const ruleSpans = (count, color, start, comet) => {
+  if (!comet) return [span("─".repeat(count), { fg: color })];
+  return Array.from({ length: count }, (_, i) => {
+    const behind = comet.dir * (comet.x - (start + i));
+    const k = behind >= 0 && behind <= COMET_TAIL ? 1 - behind / COMET_TAIL : 0;
+    return span("─", { fg: k > 0 ? cometColor(color, k) : color });
+  });
+};
+
 // An edge of the card: `open` and `close` are its corners, `left` its title or figures and
 // `right` the phase indicator, with the rule filling whatever room is left.
-const edgeRow = (open, left, right, close, width, color) => {
+const edgeRow = (open, left, right, close, width, color, comet = null) => {
   const tail = right.length ? [span(" "), ...right, span(` ${close}`, { fg: color })] : [span(close, { fg: color })];
   const fill = Math.max(1, width - textWidth(open) - rowWidth(left) - 1 - rowWidth(tail));
-  return clipRow([span(open, { fg: color }), ...left, span(" "), span("─".repeat(fill), { fg: color }), ...tail], width);
+  const start = textWidth(open) + rowWidth(left) + 1;
+  return clipRow([span(open, { fg: color }), ...left, span(" "), ...ruleSpans(fill, color, start, comet), ...tail], width);
+};
+
+// Where the ambient comet is on this card: along the top rule left to right for the first half of
+// its loop, then back along the bottom rule, starting and ending just off the card.
+const cometOn = (sample, edge, width) => {
+  const u = sample.ambient?.comet;
+  if (u === null || u === undefined) return null;
+  const span = width + 2 * COMET_TAIL;
+  if (edge === "top") return u < 0.5 ? { x: u * 2 * span - COMET_TAIL, dir: 1 } : null;
+  return u >= 0.5 ? { x: width + COMET_TAIL - (u - 0.5) * 2 * span, dir: -1 } : null;
 };
 
+// While LitClaude works the brand pill breathes from its pink toward the flame orange and back.
 const brandSpans = (sample, glyphs) => {
   const reveal = revealText("🔥 LIT", sample.pills[0]);
   if (reveal === null) return [];
-  return pill(litText(reveal, { fg: PILL.ink, bg: PILL.brand, bold: true }, sample.completion?.shimmer ?? null), PILL.brand, glyphs);
+  const fill = sample.ambient ? lerpColor(PILL.brand, PALETTE.orange, 0.85 * sample.ambient.breath) : PILL.brand;
+  return pill(litText(reveal, { fg: PILL.ink, bg: fill, bold: true }, sample.completion?.shimmer ?? null), fill, glyphs);
 };
 const indicatorSpans = (model, sample, glyphs, accent) => {
   if (sample.completion) return [span(`DONE ${glyphs.done}`, { fg: PALETTE.green, bold: true })];
   if (model.idle) return [span("idle", { fg: PALETTE.dim })];
   const current = PHASES.find((id) => model.phases[id] === "now");
   if (current) return [span(`${LABELS[current]} ${warned(current, sample) ? glyphs.warn : glyphs.now}`, { fg: phaseColor(current, sample, inkOf(accent)), bold: true })];
-  if (PHASES.every((id) => model.phases[id] === "done")) return [span(`DONE ${glyphs.done}`, { fg: PALETTE.green, bold: true })];
+  if (PHASES.every((id) => model.phases[id] === "done") && model.lanes.count === 0) return [span(`DONE ${glyphs.done}`, { fg: PALETTE.green, bold: true })];
   return [span(`LIVE ${glyphs.now}`, { fg: accent, bold: true })];
 };
 
@@ -177,10 +211,11 @@ const topEdge = (model, sample, { width, glyphs, accent, edge }) => {
   const title = (text) => (text ? [span(" · ", { fg: PALETTE.dim }), span(text, nameStyle)] : []);
   const fixed = textWidth("╭─ ") + rowWidth(brand) + 1 + 1;
   const withRight = fixed + rowWidth(title(name)) + 1 + rowWidth(right) + textWidth(" ─╮");
-  if (withRight <= width) return edgeRow("╭─ ", [...brand, ...title(name)], right, "─╮", width, edge);
+  const comet = cometOn(sample, "top", width);
+  if (withRight <= width) return edgeRow("╭─ ", [...brand, ...title(name)], right, "─╮", width, edge, comet);
   const room = width - fixed - textWidth("─╮") - textWidth(" · ");
   const shown = room >= 4 ? truncateToWidth(name, room) : "";
-  return edgeRow("╭─ ", [...brand, ...title(shown)], [], "─╮", width, edge);
+  return edgeRow("╭─ ", [...brand, ...title(shown)], [], "─╮", width, edge, comet);
 };
 
 const barSpans = (fraction, sample, cells) => barCells(fraction, cells, sample.fillGlow ?? 0)
@@ -223,7 +258,8 @@ const phaseTrack = (model, sample, { glyphs, accent, rail, short }) => {
     if (out.length) out.push(span(` ${glyphs.rail.repeat(rail)} `, { fg: sample.phases[PHASES[index - 1]].to === "done" ? ink.done : PILL.rail }));
     if (state === "now") {
       const fill = model.idle ? lerpColor(phaseColor(id, sample, ink), PILL.muted, 0.5) : phaseColor(id, sample, ink);
-      out.push(...pill([span(shown.slice(0, label.length).padEnd(label.length), { fg: PILL.ink, bg: fill, bold: true })], fill, glyphs));
+      const sweep = model.idle ? null : sample.ambient?.sweep ?? null;
+      out.push(...pill(litText(shown.slice(0, label.length).padEnd(label.length), { fg: PILL.ink, bg: fill, bold: true }, sweep), fill, glyphs));
     } else {
       out.push(span(warned(id, sample) ? shown.replace(/^[●○]/u, glyphs.warn) : shown, { fg: phaseColor(id, sample, ink) }));
     }
@@ -264,7 +300,7 @@ const CHIP_TONE = Object.freeze({
 // One chip pill: the bolt and the skill name, on the accent for this request or muted for an
 // earlier one. A chip that just arrived carries full motion's light along its name, or fills up
 // from the muted pill under subtle; a chip changing state crossfades its colours.
-const chipSpans = (chip, timed, glyphs, accent) => {
+const chipSpans = (chip, timed, glyphs, accent, sweep = null) => {
   const to = timed?.to ?? chip.state;
   const from = timed?.from ?? to;
   const mix = timed?.mix ?? 1;
@@ -275,7 +311,7 @@ const chipSpans = (chip, timed, glyphs, accent) => {
   const bold = to === "current";
   return pill([
     span(`${to === "current" ? glyphs.bolt : glyphs.recentBolt} `, { fg: text, bg: fill }),
-    ...litText(chip.id, { fg: text, bg: fill, bold }, timed?.shimmer),
+    ...litText(chip.id, { fg: text, bg: fill, bold }, timed?.shimmer ?? (to === "current" && arrive >= 1 ? sweep : null)),
   ], fill, glyphs);
 };
 
@@ -296,7 +332,8 @@ const chipsRow = (model, sample, { inner, glyphs, accent }) => {
   const row = inner >= 30 ? [span("skills", { fg: PALETTE.dim })] : [];
   let shown = 0;
   for (const chip of chips) {
-    const entry = chipSpans(chip, sample.chips?.[chip.id], glyphs, accent);
+    // While LitClaude works the light that crosses the active phase crosses this request's chips too.
+    const entry = chipSpans(chip, sample.chips?.[chip.id], glyphs, accent, model.idle ? null : sample.ambient?.sweep ?? null);
     const gap = row.length ? [span(" ")] : [];
     const rest = chips.length - shown - 1;
     const reserve = rest > 0 ? 1 + rowWidth(mutedPill(`+${rest}`, glyphs)) : 0;
@@ -346,10 +383,10 @@ const completionRow = (sample, inner) => {
 
 const levelColor = (percent) => (percent >= 90 ? HUD.red : percent >= 70 ? HUD.yellow : HUD.green);
 
-// ╰─ ctx 42% ▰▰▱▱▱ · 5h 31% · git main ───╯, or a warning first when one is up. The branch goes
-// first on a narrow card, then the rate window, then the context bar.
-const bottomEdge = (model, { width, glyphs, accent, edge }) => {
-  const { context, rate, git } = model.figures;
+// ╰─ ctx 42% ▰▰▱▱▱ · 5h 31% · 1w 12% · git main ───╯, or a warning first when one is up. The branch goes
+// first on a narrow card, then the weekly window, the five-hour one and the context bar.
+const bottomEdge = (model, sample, { width, glyphs, accent, edge }) => {
+  const { context, rates, git } = model.figures;
   const warning = model.warnings[0];
   const segments = [];
   if (warning) {
@@ -361,19 +398,21 @@ const bottomEdge = (model, { width, glyphs, accent, edge }) => {
     const filled = Math.max(0, Math.min(5, Math.round(context / 20)));
     segments.push(segment("ctxbar", 2, [span("▰".repeat(filled), { fg: accent }), span("▱".repeat(5 - filled), { fg: HUD.empty })], " "));
   }
-  if (rate) segments.push(segment("rate", 3, [span(`${rate.label} `, { fg: PALETTE.dim }), span(`${rate.percent}%`, { fg: levelColor(rate.percent) })], " · "));
+  rates.forEach((rate, index) => segments.push(segment(`rate-${rate.label}`, 3 + index * 0.5, [span(`${rate.label} `, { fg: PALETTE.dim }), span(`${rate.percent}%`, { fg: levelColor(rate.percent) })], " · ")));
   if (git) segments.push(segment("git", 4, [span(`${glyphs.branch} `, { fg: PALETTE.dim }), span(git, { fg: accent })], " · "));
   const room = width - textWidth("╰─ ") - 1 - 1 - textWidth("─╯");
   let kept = fitJoined(segments, room);
   if (kept[0]?.id === "ctxbar") kept = kept.slice(1);
   if (kept.length === 0 && warning) kept = [{ ...segments[0], spans: clipRow(segments[0].spans, room) }];
-  return edgeRow("╰─ ", joinSegments(kept, edge), [], "─╯", width, edge);
+  return edgeRow("╰─ ", joinSegments(kept, edge), [], "─╯", width, edge, cometOn(sample, "bottom", width));
 };
 
-const edgeColor = (model, accent) => {
+// The border: red or amber under a warning, otherwise the accent, dimmer while idle and breathing
+// toward full accent with the brand pill while LitClaude works.
+const edgeColor = (model, sample, accent) => {
   if (model.warnings.some(({ tone }) => tone === "red")) return PALETTE.red;
   if (model.warnings.length) return PALETTE.amber;
-  return lerpColor(PALETTE.faint, accent, model.idle ? 0.35 : 0.6);
+  return lerpColor(PALETTE.faint, accent, model.idle ? 0.35 : 0.6 + 0.4 * (sample.ambient?.breath ?? 0));
 };
 
 /**
@@ -385,7 +424,7 @@ export const composeBand = (model, sample, { columns, glyphs: glyphMode = "basic
   const glyphs = glyphSet(glyphMode);
   const width = Math.max(12, Math.min(CARD_MAX, columns));
   const inner = width - 4;
-  const edge = edgeColor(model, accent);
+  const edge = edgeColor(model, sample, accent);
   const side = (row) => [span("│ ", { fg: edge }), ...row, span(" │", { fg: edge })];
   const options = { width, inner, glyphs, accent, edge };
   const middle = sample.completion ? completionRow(sample, inner) : sample.notice ? noticeRow(sample, inner) : chipsRow(model, sample, options);
@@ -393,7 +432,7 @@ export const composeBand = (model, sample, { columns, glyphs: glyphMode = "basic
     mode: "card",
     border: edge,
     width,
-    rows: [topEdge(model, sample, options), side(phaseRow(model, sample, options)), side(middle), bottomEdge(model, options)],
+    rows: [topEdge(model, sample, options), side(phaseRow(model, sample, options)), side(middle), bottomEdge(model, sample, options)],
   };
 };
 

package/plugins/litclaude/lib/mod/motion.mjs

@@ -27,18 +27,24 @@ export const TIMINGS = Object.freeze({
   completion: 1200,
   exit: 150,
   frame: 33,
+  breath: 2400,
+  sweep: 1800,
+  comet: 2600,
+  ambientFrame: 66,
 });
 
-// full: the approved motion. subtle: no overshoot, no shimmer or embers, three quarters the time.
-// off: every duration is zero, so the band draws its final frame and never starts a frame timer.
+// full: the approved motion, and while LitClaude works the brand breathes, a light sweeps the active
+// phase and a comet runs around the card's rules. subtle: no overshoot, no shimmer or embers, three
+// quarters the time, and only the breathing while working. off: every duration is zero, so the band
+// draws its final frame and never starts a frame timer.
 export const motionProfile = (mode) => {
   if (mode === "off") {
-    return { mode, duration: () => 0, enterEase: EASE.linear, noticeEase: EASE.linear, shimmer: false, embers: false };
+    return { mode, duration: () => 0, enterEase: EASE.linear, noticeEase: EASE.linear, shimmer: false, embers: false, ambient: null };
   }
   if (mode === "subtle") {
-    return { mode, duration: (ms) => Math.round(ms * 0.75), enterEase: EASE.outCubic, noticeEase: EASE.outCubic, shimmer: false, embers: false };
+    return { mode, duration: (ms) => Math.round(ms * 0.75), enterEase: EASE.outCubic, noticeEase: EASE.outCubic, shimmer: false, embers: false, ambient: { sweep: false, comet: false } };
   }
-  return { mode: "full", duration: (ms) => ms, enterEase: EASE.outBack, noticeEase: EASE.outBack, shimmer: true, embers: true };
+  return { mode: "full", duration: (ms) => ms, enterEase: EASE.outBack, noticeEase: EASE.outBack, shimmer: true, embers: true, ambient: { sweep: true, comet: true } };
 };
 
 export const clamp01 = (x) => (x <= 0 ? 0 : x >= 1 ? 1 : x);

package/plugins/litclaude/lib/mod/settings.mjs

@@ -3,7 +3,7 @@
 // one; the values are checked here instead, and anything unknown falls back to the default (the
 // first choice).
 
-const CHOICES = Object.freeze({
+export const MOD_CHOICES = Object.freeze({
   motion: ["full", "subtle", "off"],
   glyphs: ["auto", "nerd", "basic"],
   band: ["always", "auto", "off"],
@@ -15,9 +15,9 @@ const pick = (value, choices) => {
 };
 
 export const normalizeModSettings = (options) => ({
-  motion: pick(options?.motion, CHOICES.motion),
-  glyphs: pick(options?.glyphs, CHOICES.glyphs),
-  band: pick(options?.band, CHOICES.band),
+  motion: pick(options?.motion, MOD_CHOICES.motion),
+  glyphs: pick(options?.glyphs, MOD_CHOICES.glyphs),
+  band: pick(options?.band, MOD_CHOICES.band),
 });
 
 // The glyph set one surface draws. Private-use Nerd Font glyphs only reach the terminal, which

package/plugins/litclaude/lib/mod/timeline.mjs

@@ -22,9 +22,17 @@ const chipsOf = (model, now, previous = null) => Object.fromEntries((model.skill
   return [chip.id, known];
 }));
 
+// The ambient loop runs while the card shows LitClaude at work, so motion itself says "active";
+// `at` is when the current run of work began, so the loop does not restart on every new model.
+const ambientOf = (model, now, profile, previous = null) => {
+  const on = Boolean(profile.ambient) && model.visible && !model.idle;
+  return { on, at: on && previous?.on ? previous.at : now };
+};
+
 export const createTimeline = (model, now, profile) => {
   const restAt = now + entryEnd(profile);
   return {
+    ambient: ambientOf(model, now, profile),
     enterAt: now,
     exitAt: null,
     fill: { from: 0, to: fractionOf(model), at: restAt, dur: profile.duration(TIMINGS.fill) },
@@ -63,9 +71,28 @@ export const advanceTimeline = (timeline, model, now, profile) => {
     next.completion = model.completion ? { data: model.completion, at: now } : null;
   }
   next.chips = chipsOf(model, now, timeline.chips);
+  next.ambient = ambientOf(model, now, profile, timeline.ambient);
   return next;
 };
 
+/** True while the ambient loop runs; the surface module then keeps a slower frame timer going. */
+export const ambientActive = (timeline, profile) => Boolean(profile.ambient) && timeline.exitAt === null && timeline.ambient.on;
+
+// One frame of the ambient loop: `breath` (0 to 1 and back over TIMINGS.breath), where the light
+// stands on the active phase (`sweep`, null between passes) and how far the comet has gone around
+// the card (`comet`, 0 to 1: the top rule left to right, then the bottom rule right to left).
+const ambientSample = (timeline, now, profile) => {
+  if (!ambientActive(timeline, profile)) return null;
+  const elapsed = Math.max(0, now - timeline.ambient.at);
+  const breath = 0.5 - 0.5 * Math.cos((2 * Math.PI * elapsed) / TIMINGS.breath);
+  const pass = ((elapsed % TIMINGS.sweep) / TIMINGS.sweep) * 1.6 - 0.3;
+  return {
+    breath,
+    sweep: profile.ambient.sweep && pass >= -0.2 && pass <= 1.2 ? pass : null,
+    comet: profile.ambient.comet ? (elapsed % TIMINGS.comet) / TIMINGS.comet : null,
+  };
+};
+
 export const timelineBusy = (timeline, now, profile) => {
   const d = profile.duration;
   if (timeline.exitAt !== null) return now < timeline.exitAt + d(TIMINGS.exit);
@@ -142,6 +169,7 @@ export const sampleTimeline = (timeline, now, profile) => {
     notice,
     completion,
     chips,
+    ambient: ambientSample(timeline, now, profile),
   };
 };
 

package/plugins/litclaude/lib/mod/view.mjs

@@ -5,10 +5,14 @@
 import { AUTOLOOP_LIMITS, GATE_LIMITS } from "./state.mjs";
 
 export const STALL_MS = 10 * 60 * 1000;
+// An agent quiet for this long no longer counts as running: a crashed loop or a lost report must not
+// hold the card at work for the rest of the session.
+export const AGENT_STALE_MS = 30 * 60 * 1000;
 // The context warning starts this many points before the auto-handoff percent.
 export const CONTEXT_LEAD = 5;
 
 const LIVE_AGENT = new Set(["running", "pending", "waiting", "idle"]);
+const ENDED_AGENT = new Set(["completed", "failed", "killed"]);
 const NONTERMINAL_GOAL = new Set(["active", "blocked", "review_blocked", "needs_user_decision"]);
 const WORK_DISCIPLINES = new Set(["lit-loop", "litwork", "litgoal", "start-work", "native-workflow"]);
 
@@ -44,6 +48,31 @@ export const trackAgents = (activity, agents, previousStatus, now) => {
 export const noteAgentActivity = (activity, agentId, now) =>
   activity.first[agentId] === undefined ? activity : { ...activity, last: { ...activity.last, [agentId]: now } };
 
+// `spawned` maps an agent id to what `agent.spawn` said of it and when it was last seen working. It
+// covers the agents `$.agent.list()` never shows (a workflow script's) and the moment before the
+// list catches up; the agent's own `turn.complete` ends it.
+export const noteSpawn = (spawned, { id, description, type, at }) => ({ ...spawned, [id]: { id, description, type, last: at } });
+
+export const noteSpawnActivity = (spawned, id, at) => (spawned[id] ? { ...spawned, [id]: { ...spawned[id], last: at } } : spawned);
+
+export const noteSpawnEnded = (spawned, id) => Object.fromEntries(Object.entries(spawned).filter(([key]) => key !== id));
+
+// Folds the spawn records into one `$.agent.list()` reading. The list speaks for the agents it shows:
+// a record whose agent it lists as ended is dropped. A record it does not show runs until its
+// `turn.complete`, or until it has been quiet for AGENT_STALE_MS.
+export const mergeSpawned = (listed, spawned, now) => {
+  const byId = new Map(listed.map((agent) => [agent.id, agent]));
+  const kept = {};
+  const unlisted = [];
+  for (const record of Object.values(spawned)) {
+    const row = byId.get(record.id);
+    if (row ? ENDED_AGENT.has(row.status) : now - record.last > AGENT_STALE_MS) continue;
+    kept[record.id] = record;
+    if (!row) unlisted.push({ id: record.id, description: record.description, type: record.type, status: "running" });
+  }
+  return { agents: [...listed, ...unlisted], spawned: kept };
+};
+
 export const stalledLanes = (agents, activity, now, thresholdMs = STALL_MS) =>
   agents
     .filter((agent) => LIVE_AGENT.has(agent.status) && Number.isFinite(activity.last[agent.id]) && now - activity.last[agent.id] > thresholdMs)
@@ -108,14 +137,16 @@ const goalSummaryOf = (goal) => {
   return { status: goal.status, passed: goal.criteria.filter(({ status }) => status === "pass").length, total: goal.criteria.length };
 };
 
-// The bottom edge's live figures, as the status line shows them: context fill, the five-hour
-// window (the weekly one when that is all there is) and the Git branch.
+// The bottom edge's live figures, as the status line shows them: context fill, the five-hour and
+// weekly windows and the Git branch.
 const figuresOf = (usage, git) => {
   const context = Number.isFinite(usage?.context?.percent) ? Math.round(usage.context.percent) : null;
   const windows = Array.isArray(usage?.rateLimits) ? usage.rateLimits : [];
-  const window = windows.find(({ kind }) => kind === "five_hour") ?? windows.find(({ kind }) => kind === "seven_day") ?? null;
-  const rate = window && Number.isFinite(window.percentUsed) ? { label: window.kind === "five_hour" ? "5h" : "1w", percent: Math.round(window.percentUsed) } : null;
-  return { context, rate, git: typeof git === "string" && git ? git : null };
+  const rates = [["five_hour", "5h"], ["seven_day", "1w"]].flatMap(([kind, label]) => {
+    const window = windows.find((entry) => entry.kind === kind);
+    return window && Number.isFinite(window.percentUsed) ? [{ label, percent: Math.round(window.percentUsed) }] : [];
+  });
+  return { context, rates, git: typeof git === "string" && git ? git : null };
 };
 
 /**
@@ -129,7 +160,7 @@ export const buildBandModel = ({ snapshot, agents = [], activity = EMPTY_ACTIVIT
   const progress = progressOf(snapshot);
   const completing = completion !== null;
   const phases = phasesOf({ snapshot, discipline, progress, completing });
-  const liveAgents = agents.filter((agent) => LIVE_AGENT.has(agent.status));
+  const liveAgents = agents.filter((agent) => LIVE_AGENT.has(agent.status) && !(now - activity.last[agent.id] > AGENT_STALE_MS));
   const boulderLanes = (snapshot.work?.lanes ?? []).filter(({ status }) => status === "active");
   const stalls = stalledLanes(agents, activity, now);
   const stalledIds = new Set(stalls.map(({ id }) => id));