opencode-courier 0.7.2 → 0.8.0

package/dist/tui.js

@@ -2,58 +2,471 @@
 // src/tui.tsx
 import { Plugin } from "@opencode/plugin/tui";
 
-// src/person/rpc.ts
+// src/memory/rpc.ts
 import { Rpc } from "@opencode/plugin/rpc";
 import { Schema } from "effect";
 var Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-var Session = Schema.Struct({
+var PART_STATUSES = ["done", "partial", "blocked", "failed", "interrupted", "stopped", "stalled", "out"];
+var Part = Schema.Struct({
   sessionID: Schema.String,
   title: Schema.String,
-  parentID: Schema.String,
   depth: Count,
-  group: Schema.optionalKey(Schema.String)
+  isolated: Schema.Boolean,
+  group: Schema.optionalKey(Schema.String),
+  status: Schema.Literals(PART_STATUSES),
+  duration: Schema.optionalKey(Schema.Number),
+  cost: Schema.optionalKey(Schema.Number),
+  context: Schema.optionalKey(Schema.Number),
+  refused: Schema.optionalKey(Count)
 });
-var Permission = Schema.Struct({
+var Lesson = Schema.Struct({ text: Schema.String, at: Schema.Number, depth: Schema.optionalKey(Count) });
+var Record = Schema.Struct({
   sessionID: Schema.String,
-  requestID: Schema.String,
-  action: Schema.String,
-  resources: Schema.Array(Schema.String),
-  save: Schema.optionalKey(Schema.Array(Schema.String)),
-  passesOn: Schema.optionalKey(Schema.Struct({ sessionID: Schema.String, requestID: Schema.String }))
+  startedAt: Schema.Number,
+  movedAt: Schema.Number,
+  title: Schema.String,
+  split: Schema.String,
+  finished: Schema.Boolean,
+  recalled: Schema.optionalKey(Schema.Struct({ at: Schema.optionalKey(Schema.Number), calls: Count })),
+  lesson: Schema.optionalKey(Lesson),
+  parts: Schema.Array(Part)
 });
-var Prompt = Schema.Struct({
-  question: Schema.String,
-  header: Schema.String,
-  options: Schema.Array(Schema.Struct({ label: Schema.String, description: Schema.String })),
-  multiple: Schema.optionalKey(Schema.Boolean)
+var Records = Schema.Struct({
+  memory: Schema.Boolean,
+  projectID: Schema.String,
+  records: Schema.Array(Record)
 });
-var Question = Schema.Struct({
-  sessionID: Schema.String,
-  requestID: Schema.String,
-  questions: Schema.Array(Prompt),
-  stopped: Schema.optionalKey(Schema.Boolean)
+var Forgotten = Schema.Struct({ outcome: Schema.Literals(["record", "lesson", "none"]) });
+var memoryRpc = Rpc.define({
+  id: "courier-memory",
+  methods: {
+    records: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({})),
+      output: Schema.toStandardSchemaV1(Records)
+    },
+    forget: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, lesson: Schema.optionalKey(Schema.Boolean) })),
+      output: Schema.toStandardSchemaV1(Forgotten)
+    }
+  },
+  events: {}
 });
-var Asks = Schema.Struct({
-  top: Schema.String,
-  sessions: Schema.Array(Session),
-  permissions: Schema.Array(Permission),
-  questions: Schema.Array(Question)
+
+// src/kernel/protocol.ts
+var STATUSES = ["done", "partial", "blocked", "failed"];
+
+// src/memory/domain.ts
+var RETENTION_MS = 90 * 24 * 60 * 60000;
+var PART_STATUSES2 = [...STATUSES, "interrupted", "stopped", "stalled", "out"];
+
+// src/memory/text.ts
+function duration(ms) {
+  const minutes = Math.round(ms / 60000);
+  if (minutes < 1)
+    return `${Math.max(0, Math.round(ms / 1000))} s`;
+  if (minutes < 60)
+    return `${minutes} min`;
+  return `${Math.floor(minutes / 60)} h ${minutes % 60} min`;
+}
+var ONE_LINE = "what the next orchestrator in this project should know about running a tree like this one, with the job it comes from and the reason";
+var NOTE_EMPTY = `Not noted: text is empty. Write one line, ${ONE_LINE}, or nothing.`;
+
+// src/memory/tui.tsx
+var MEMORY_COMMAND = "courier.memory";
+var MEMORY_USAGE = "/courier memory lists this project's tree records, to read or forget";
+var MEMORY_OFF = "Memory is off in this project: the plugin's memory option is false, so no record of a session tree is kept or listed here.";
+var NO_RECORDS = "No record of a session tree in this project: one is written as each turn in a tree ends, and kept 90 days.";
+var LESSON_LINE_MAX = 160;
+var ROW_TITLE_MAX = 46;
+var TODAY = "Today";
+var LESSON_ROW = 90;
+var pad = (n) => String(n).padStart(2, "0");
+var localDay = (at) => new Date(at).toDateString();
+var day = (at) => {
+  const date = new Date(at);
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+};
+var zone = (date) => new Intl.DateTimeFormat("en-US", {
+  timeZoneName: "short"
+}).formatToParts(date).find((part) => part.type === "timeZoneName")?.value ?? "local";
+var minute = (at) => {
+  const date = new Date(at);
+  return `${day(at)} ${pad(date.getHours())}:${pad(date.getMinutes())} ${zone(date)}`;
+};
+var oneLine2 = (text) => text.replace(/\s+/g, " ").trim();
+var clip = (text, max) => text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+var count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+var money = (cost) => `$${cost.toFixed(2)}`;
+var nameOf = (record) => clip(oneLine2(record.title) || record.sessionID, 60);
+function partsCounted(parts) {
+  if (!parts.length)
+    return "no parts";
+  const statuses = PART_STATUSES.flatMap((status) => {
+    const n = parts.filter((part) => part.status === status).length;
+    return n ? [`${n} ${status}`] : [];
+  }).join(", ");
+  return `${count(parts.length, "part")}: ${statuses}`;
+}
+function costOf(record) {
+  return record.parts.some((part) => part.cost !== undefined) ? record.parts.reduce((sum, part) => sum + (part.cost ?? 0), 0) : undefined;
+}
+function recordTitle(record, open) {
+  return `${clip(oneLine2(record.title) || record.sessionID, ROW_TITLE_MAX)}${record.sessionID === open ? " (this session)" : ""}`;
+}
+function recordCategory(record, now = Date.now()) {
+  const moved = localDay(record.movedAt);
+  return moved === localDay(now) ? TODAY : moved;
+}
+function lessonHeading(lesson) {
+  const from = lesson.depth === undefined ? "" : `, from depth ${lesson.depth}`;
+  return `lesson (${day(lesson.at)}${from})`;
+}
+function recordDescription(record) {
+  const cost = costOf(record);
+  return [partsCounted(record.parts), duration(record.movedAt - record.startedAt), cost === undefined ? "" : money(cost), record.finished ? "" : "not finished"].filter(Boolean).join(" \xB7 ");
+}
+function recordDetails(record) {
+  return record.lesson ? [clip(`${lessonHeading(record.lesson)}: "${oneLine2(record.lesson.text)}"`, LESSON_LINE_MAX)] : [];
+}
+function partLine(part) {
+  return [part.status, `depth ${part.depth}`, part.isolated ? "isolated" : "", part.group ? `group ${part.group}` : "", part.duration === undefined ? "" : duration(part.duration), part.cost === undefined ? "" : money(part.cost), part.context === undefined ? "" : `ctx ${Math.round(part.context * 100)}%`, part.refused ? `${count(part.refused, "spawn")} refused` : ""].filter(Boolean).join(" \xB7 ");
+}
+function wrap(text, width) {
+  const rows = [];
+  let row = "";
+  for (const word of oneLine2(text).split(" ").filter(Boolean)) {
+    if (row && row.length + 1 + word.length <= width) {
+      row = `${row} ${word}`;
+      continue;
+    }
+    if (row)
+      rows.push(row);
+    row = word;
+    while (row.length > width) {
+      rows.push(row.slice(0, width));
+      row = row.slice(width);
+    }
+  }
+  if (row)
+    rows.push(row);
+  return rows;
+}
+var lessonLine = (record) => record.lesson ? {
+  kind: "lesson",
+  row: 0
+} : {
+  kind: "fact",
+  key: "lesson"
+};
+function nearby(sessionIDs, sessionID, forgotten) {
+  const at = sessionIDs.indexOf(sessionID);
+  if (at < 0)
+    return forgotten ? [] : [sessionID];
+  return [...forgotten ? [] : [sessionID], ...sessionIDs.slice(at + 1), ...sessionIDs.slice(0, at).reverse()];
+}
+function detailOptions(record) {
+  const fact = (key, title, description) => ({
+    title,
+    value: {
+      kind: "fact",
+      key
+    },
+    category: "Tree",
+    ...description ? {
+      description
+    } : {}
+  });
+  const cost = costOf(record);
+  const recalled = record.recalled ? fact("recalled", `Recalled ${count(record.recalled.calls, "time")}`, record.recalled.at === undefined ? "by a part only" : `first by the top ${minute(record.recalled.at)}`) : fact("recalled", "Not recalled");
+  const lesson = record.lesson ? [{
+    title: lessonHeading(record.lesson),
+    value: {
+      kind: "lesson",
+      row: 0
+    },
+    category: "Lesson"
+  }, ...wrap(record.lesson.text, LESSON_ROW).map((row, at) => ({
+    title: row,
+    value: {
+      kind: "lesson",
+      row: at + 1
+    },
+    category: "Lesson"
+  }))] : [{
+    title: "No lesson",
+    value: {
+      kind: "fact",
+      key: "lesson"
+    },
+    category: "Lesson",
+    description: "courier_note writes one line per tree"
+  }];
+  return [fact("top", `Top session ${record.sessionID}`), fact("started", `Started ${minute(record.startedAt)}`, `last moved ${minute(record.movedAt)}, ran ${duration(record.movedAt - record.startedAt)}`), fact("split", clip(oneLine2(record.split), 160)), fact("finished", record.finished ? "Finished" : "Not finished", cost === undefined ? undefined : `${money(cost)} in all`), recalled, ...record.parts.length ? record.parts.map((part) => ({
+    title: `${"  ".repeat(Math.max(0, part.depth - 1))}${clip(oneLine2(part.title) || part.sessionID, 60)}`,
+    value: {
+      kind: "part",
+      sessionID: part.sessionID
+    },
+    category: "Parts",
+    description: partLine(part)
+  })) : [{
+    title: "No parts",
+    value: {
+      kind: "fact",
+      key: "parts"
+    },
+    category: "Parts",
+    description: "no session was started in this tree"
+  }], ...lesson];
+}
+function forgetMessage(record, lesson) {
+  const name = `"${nameOf(record)}" (${day(record.movedAt)}, ${partsCounted(record.parts)})`;
+  if (lesson)
+    return `Forget the lesson of ${name}? The record keeps its facts; courier_recall no longer lists the lesson: "${clip(oneLine2(record.lesson?.text ?? ""), 120)}".`;
+  return `Forget the record of ${name}, top session ${record.sessionID}? It leaves this project's memory and courier_recall${record.lesson ? ", its lesson with it" : ""}; the sessions themselves are untouched.`;
+}
+function forgottenLine(record, outcome) {
+  const name = `"${nameOf(record)}"`;
+  if (outcome === "record")
+    return `Forgot the record of ${name}`;
+  if (outcome === "lesson")
+    return `Forgot the lesson of ${name}; its facts stay`;
+  return `Nothing to forget for ${name}: it was already gone`;
+}
+function addMemoryView(ctx) {
+  const memory = ctx.client.rpc(memoryRpc);
+  const openSession = () => {
+    const route = ctx.ui.router.current();
+    return route.type === "session" ? route.sessionID : undefined;
+  };
+  const where = () => {
+    const sessionID = openSession();
+    return (sessionID ? ctx.data.session.get(sessionID)?.location : undefined) ?? ctx.location ?? ctx.data.location.default();
+  };
+  const reason = (error) => {
+    if (error instanceof Error)
+      return error.message;
+    return typeof error === "object" && error && "message" in error ? String(error.message) : String(error);
+  };
+  const fail = (what) => (error) => ctx.ui.toast.show({
+    title: "courier",
+    message: `${what}: ${reason(error)}`,
+    variant: "error"
+  });
+  const say = (message) => ctx.ui.toast.show({
+    title: "courier",
+    message,
+    variant: "info"
+  });
+  function show(options, chosen, forget) {
+    let request = () => {
+      return;
+    };
+    const requested = new Promise((resolve) => {
+      request = resolve;
+    });
+    const choosing = ctx.ui.dialog.select({
+      ...options,
+      actions: [{
+        bind: "x",
+        title: "forget",
+        onTrigger: (value) => request(forget(value))
+      }]
+    });
+    ctx.ui.dialog.set({
+      size: "xlarge"
+    });
+    return Promise.race([choosing.then((value) => value === undefined ? {
+      kind: "back"
+    } : chosen(value)), requested]);
+  }
+  const showList = (read, current) => {
+    const open2 = openSession();
+    const now = Date.now();
+    return show({
+      title: `Memory (${read.records.length})`,
+      placeholder: "Search",
+      ...current ? {
+        current
+      } : {},
+      options: read.records.map((record) => ({
+        title: recordTitle(record, open2),
+        value: record,
+        category: recordCategory(record, now),
+        description: recordDescription(record),
+        details: recordDetails(record)
+      }))
+    }, (record) => ({
+      kind: "open",
+      record
+    }), (record) => ({
+      kind: "forget",
+      record,
+      lesson: false
+    }));
+  };
+  const showRecord = (record, current) => show({
+    title: `${localDay(record.movedAt)}  ${nameOf(record)}`,
+    placeholder: "Search",
+    options: detailOptions(record),
+    ...current ? {
+      current
+    } : {}
+  }, () => ({
+    kind: "back"
+  }), (line) => ({
+    kind: "forget",
+    record,
+    lesson: line.kind === "lesson",
+    line
+  }));
+  async function confirmForget(record, lesson) {
+    const confirmed = await ctx.ui.dialog.confirm({
+      title: lesson ? "Forget lesson" : "Forget record",
+      message: forgetMessage(record, lesson),
+      label: {
+        confirm: "Forget",
+        cancel: "Keep"
+      }
+    });
+    if (!confirmed)
+      return false;
+    try {
+      const result = await memory.forget({
+        sessionID: record.sessionID,
+        lesson
+      }, {
+        location: where()
+      });
+      ctx.ui.toast.show({
+        title: "courier",
+        message: forgottenLine(record, result.outcome),
+        variant: result.outcome === "none" ? "warning" : "success"
+      });
+      return true;
+    } catch (error) {
+      fail("Not forgotten")(error);
+      return false;
+    }
+  }
+  let opened = false;
+  async function open() {
+    if (opened)
+      return;
+    opened = true;
+    try {
+      let viewing;
+      let near = [];
+      let line;
+      for (;; ) {
+        const read = await memory.records({}, {
+          location: where()
+        }).catch(fail("The records could not be read"));
+        if (!read)
+          return;
+        if (!read.memory)
+          return say(MEMORY_OFF);
+        if (!read.records.length)
+          return say(NO_RECORDS);
+        const record = viewing === undefined ? undefined : read.records.find((one) => one.sessionID === viewing);
+        viewing = record?.sessionID;
+        const listed = read.records.map((one) => one.sessionID);
+        const current = near.map((sessionID) => read.records.find((one) => one.sessionID === sessionID)).find((one) => one !== undefined);
+        const at = line === "lesson" ? record && lessonLine(record) : line;
+        const request = await (record ? showRecord(record, at) : showList(read, current));
+        line = undefined;
+        if (request.kind === "back") {
+          if (!record)
+            return;
+          near = nearby(listed, record.sessionID, false);
+          viewing = undefined;
+          continue;
+        }
+        if (request.kind === "open") {
+          viewing = request.record.sessionID;
+          continue;
+        }
+        const forgotten = await confirmForget(request.record, request.lesson);
+        near = nearby(listed, request.record.sessionID, forgotten && !request.lesson);
+        if (record && !forgotten)
+          line = request.line;
+        else if (request.lesson)
+          line = "lesson";
+        else
+          viewing = undefined;
+      }
+    } finally {
+      opened = false;
+    }
+  }
+  ctx.keymap.layer(() => ({
+    mode: "global",
+    commands: [{
+      id: MEMORY_COMMAND,
+      title: "Courier: memory",
+      description: "The records of this project's session trees, newest first under the day each last moved: enter for one in full, x to forget one or its lesson",
+      group: "Courier",
+      palette: true,
+      run: () => void open()
+    }]
+  }));
+  return {
+    open
+  };
+}
+
+// src/person/rpc.ts
+import { Rpc as Rpc2 } from "@opencode/plugin/rpc";
+import { Schema as Schema2 } from "effect";
+var Count2 = Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0));
+var Session = Schema2.Struct({
+  sessionID: Schema2.String,
+  title: Schema2.String,
+  parentID: Schema2.String,
+  depth: Count2,
+  group: Schema2.optionalKey(Schema2.String)
+});
+var Permission = Schema2.Struct({
+  sessionID: Schema2.String,
+  requestID: Schema2.String,
+  action: Schema2.String,
+  resources: Schema2.Array(Schema2.String),
+  save: Schema2.optionalKey(Schema2.Array(Schema2.String)),
+  passesOn: Schema2.optionalKey(Schema2.Struct({ sessionID: Schema2.String, requestID: Schema2.String }))
+});
+var Prompt = Schema2.Struct({
+  question: Schema2.String,
+  header: Schema2.String,
+  options: Schema2.Array(Schema2.Struct({ label: Schema2.String, description: Schema2.String })),
+  multiple: Schema2.optionalKey(Schema2.Boolean)
+});
+var Question = Schema2.Struct({
+  sessionID: Schema2.String,
+  requestID: Schema2.String,
+  questions: Schema2.Array(Prompt),
+  stopped: Schema2.optionalKey(Schema2.Boolean)
 });
-var Answered = Schema.Struct({
-  answered: Schema.Boolean,
-  by: Schema.optionalKey(Schema.Literals(["result", "message"])),
-  problem: Schema.optionalKey(Schema.String)
+var Asks = Schema2.Struct({
+  top: Schema2.String,
+  sessions: Schema2.Array(Session),
+  permissions: Schema2.Array(Permission),
+  questions: Schema2.Array(Question)
 });
-var personRpc = Rpc.define({
+var Answered = Schema2.Struct({
+  answered: Schema2.Boolean,
+  by: Schema2.optionalKey(Schema2.Literals(["result", "message"])),
+  problem: Schema2.optionalKey(Schema2.String)
+});
+var personRpc = Rpc2.define({
   id: "courier-person",
   methods: {
     asks: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
-      output: Schema.toStandardSchemaV1(Asks)
+      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String })),
+      output: Schema2.toStandardSchemaV1(Asks)
     },
     answer: {
-      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, requestID: Schema.String, answers: Schema.Array(Schema.Array(Schema.String)) })),
-      output: Schema.toStandardSchemaV1(Answered)
+      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String, requestID: Schema2.String, answers: Schema2.Array(Schema2.Array(Schema2.String)) })),
+      output: Schema2.toStandardSchemaV1(Answered)
     }
   },
   events: {}
@@ -103,7 +516,7 @@ function pathOf(asks, sessionID, topTitle, currentTitle = () => {
     titles.unshift(currentTitle(at.sessionID) || at.title);
   return [topTitle, ...titles].join(" \u203A ");
 }
-var clip = (text, max = 80) => text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+var clip2 = (text, max = 80) => text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 function askTitle(ask) {
   switch (ask.kind) {
     case "permission": {
@@ -114,17 +527,17 @@ function askTitle(ask) {
       } = ask.request;
       const what = resources.length ? `${action} ${resources.join(", ")}` : action;
       if (ask.session.depth > 0)
-        return clip(`Permission: ${what}`);
-      return clip(passesOn ? `Permission (top session): courier_answer once for "${what}"` : `Permission (top session): ${what}`);
+        return clip2(`Permission: ${what}`);
+      return clip2(passesOn ? `Permission (top session): courier_answer once for "${what}"` : `Permission (top session): ${what}`);
     }
     case "question": {
       const [first, ...rest] = ask.question.questions;
       const what = first ? `${first.header}: ${first.question}` : ask.question.requestID;
       const more = rest.length ? ` (+${rest.length} more)` : "";
-      return clip(`Question: ${what}${more}`);
+      return clip2(`Question: ${what}${more}`);
     }
     case "form":
-      return clip(`Form: ${ask.form.title}`);
+      return clip2(`Form: ${ask.form.title}`);
   }
 }
 function askFooter(ask) {
@@ -384,12 +797,12 @@ function addAsksInbox(ctx, follows) {
     } = ask;
     const answers = [];
     for (const [index, prompt] of question.questions.entries()) {
-      const count = question.questions.length > 1 ? ` (${index + 1}/${question.questions.length})` : "";
+      const count2 = question.questions.length > 1 ? ` (${index + 1}/${question.questions.length})` : "";
       const choices = prompt.options.map((option) => ({
         ...option,
         value: option.label
       }));
-      const picked = await choose(`${prompt.header}: ${prompt.question}${count}`, choices, {
+      const picked = await choose(`${prompt.header}: ${prompt.question}${count2}`, choices, {
         multiple: !!prompt.multiple,
         own: true
       });
@@ -797,76 +1210,224 @@ import { createTextNode as _$createTextNode } from "@opentui/solid";
 import { insertNode as _$insertNode } from "@opentui/solid";
 import { setProp as _$setProp } from "@opentui/solid";
 import { createElement as _$createElement } from "@opentui/solid";
-import { createEffect, createMemo, createResource, createRoot, createSignal, For, on, onCleanup, onMount, Show, untrack } from "solid-js";
+import { MouseButton, RGBA, Timeline } from "@opentui/core";
+import { batch, createEffect, createMemo, createResource, createRoot, createSignal, For, Index, on, onCleanup, onMount, Show, untrack } from "solid-js";
+
+// src/tree/mascot.ts
+var MASCOT_EVERY = 5;
+var BLINK_EVERY = 11;
+var GLYPH = {
+  idle: [["........", "........", "..gggg..", "gggggggg"]],
+  spawn: [
+    ["........", "...bb...", "g.bbbb.g", "gggggggg"],
+    [".g....g.", "...bb...", "ggbbbbgg", "gggggggg"]
+  ],
+  running: [
+    ["..g..g..", "...bb...", ".gbbbbg.", "gggggggg"],
+    [".g....g.", "........", ".gbbbbg.", "gggggggg"]
+  ],
+  waiting: [
+    [".bbbbbbw", ".bkbbkbw", ".bbaabbm", "ggggggg."],
+    [".bbbbbbb", ".bkbbkbb", ".bbaabbm", "ggggggg."]
+  ],
+  stalled: [
+    ["..e.....", ".bbbbbb.", ".bkbbkb.", "gbbaabbg"],
+    ["..e.e...", ".bbbbbb.", ".bkbbkb.", "gbbaabbg"],
+    ["..e.e.e.", ".bbbbbb.", ".bkbbkb.", "gbbaabbg"]
+  ],
+  report: [
+    ["......aa", "bbbbbbaa", "bkbbkbm.", "bbaabbm."],
+    ["s.....aa", "bbbbbbaa", "bkbbkbm.", "bbaabbm."]
+  ],
+  gone: [["........", ".mmmmmm.", ".mkmmkm.", "mmmmmmmm"]]
+};
+var OPEN_EYES = new Set(["waiting", "report"]);
+function glyph(state, frame) {
+  const frames = GLYPH[state];
+  const pixels = frames[(frame ?? 0) % frames.length];
+  if (frame === undefined)
+    return pixels;
+  if (state === "idle" && breathesOut(frame))
+    return [...pixels.slice(0, 2), ".gggggg.", ...pixels.slice(3)];
+  return OPEN_EYES.has(state) && blinks(frame) ? pixels.map((row) => row.replaceAll("k", "b")) : pixels;
+}
+var breathesOut = (frame) => Math.floor(frame / 2) % 2 === 1;
+var blinks = (frame) => frame % BLINK_EVERY === BLINK_EVERY - 1;
+function cells(pixels) {
+  const lines = [];
+  for (let row = 0;row < pixels.length; row += 2) {
+    const top = pixels[row];
+    const bottom = pixels[row + 1] ?? "";
+    lines.push([...top].map((pixel, column) => cell(token(pixel), token(bottom[column]))));
+  }
+  return lines;
+}
+var token = (pixel) => pixel && pixel !== "." ? pixel : undefined;
+function cell(top, bottom) {
+  if (!top && !bottom)
+    return { char: " " };
+  if (!top)
+    return { char: "\u2584", fg: bottom };
+  if (top === bottom)
+    return { char: "\u2588", fg: top };
+  return bottom ? { char: "\u2580", fg: top, bg: bottom } : { char: "\u2580", fg: top };
+}
+var SIZE = 16;
+var SLUMP = [2, 2, 2, 1, 1, 0, 0];
+function digby(rise, { top = 6, eyes = "open", slump = false, shift = 0, mound = "g" } = {}) {
+  const grid = Array.from({ length: SIZE }, () => new Array(SIZE).fill("."));
+  const span = (row, width, pixel, skip = (_column) => false, by = 0) => {
+    if (row < 0 || row >= SIZE)
+      return;
+    for (let column = (SIZE - width) / 2;column < (SIZE + width) / 2; column++)
+      if (!skip(column))
+        grid[row][column + by] = pixel;
+  };
+  const head = Math.round(10 - 8 * rise);
+  const lean = (at) => slump ? SLUMP[at] : 0;
+  [4, 6, 8, 8, 8, 6, 4].forEach((width, at) => span(head + at, width, "b", undefined, lean(at)));
+  for (let row = head + 7;row <= 11; row++)
+    span(row, 4, "b");
+  const eyeColumns = eyes === "shut" ? [5, 6, 9, 10] : [6, 9];
+  if (eyes !== "none")
+    span(head + 3, 8, "k", (column) => !eyeColumns.includes(column), lean(3));
+  if (eyes === "wide")
+    span(head + 2, 8, "k", (column) => !eyeColumns.includes(column), lean(2));
+  span(head + 4, 2, "a", undefined, lean(4));
+  span(10, SIZE, ".", (column) => column >= 6 && column <= 9);
+  span(10, top, mound, (column) => column >= 6 && column <= 9, shift);
+  span(11, 10, mound, undefined, shift);
+  span(12, 12, mound, undefined, shift);
+  for (const row of [13, 14, 15])
+    span(row, SIZE, mound);
+  return grid.map((row) => row.join(""));
+}
+function paint(pixels, spots) {
+  const grid = pixels.map((row) => [...row]);
+  for (const [row, column, drawn] of spots)
+    [...drawn].forEach((pixel, at) => {
+      if (pixel !== "." && grid[row]?.[column + at] !== undefined)
+        grid[row][column + at] = pixel;
+    });
+  return grid.map((row) => row.join(""));
+}
+var post = (row, column, length, pixel) => Array.from({ length }, (_, at) => [row + at, column, pixel]);
+var headTop = (rise) => Math.round(10 - 8 * rise);
+var running = (rise, shift, dirt) => paint(digby(rise, { shift }), [[headTop(rise), 7, "aa"], ...dirt]);
+var peek = (column, up) => [
+  ...up ? [[8, column, ".b."], [9, column, "bkb"]] : [[9, column, ".b."]],
+  [10, column, "gbg"],
+  [11, column, "ggg"]
+];
+var spawn = (up, dirt) => paint(digby(0.1), [...peek(0, up), ...peek(13, up), [12, 0, "gg"], [12, 14, "gg"], ...dirt]);
+var sign = (shown) => [...shown ? [[2, 13, "www"], [3, 13, "wkw"], [4, 13, "www"]] : [], ...post(5, 14, 7, "m")];
+var waiting = (shown) => (open) => paint(digby(1, { eyes: open ? "wide" : "none" }), [[8, 4, "mm"], [8, 10, "mm"], ...sign(shown)]);
+var stalled = (dots) => () => paint(digby(0.7, { eyes: "shut", slump: true }), [[5, 0, dots]]);
+var report = (rise, spark) => (open) => paint(digby(rise, { eyes: open ? "open" : "none" }), [
+  [0, 12, "aaaa"],
+  [1, 12, "akka"],
+  [2, 12, "aaaa"],
+  ...post(3, 13, 8, "m"),
+  ...spark.map((row, at) => [1 + at, 0, row])
+]);
+var ART = {
+  spawn: [
+    () => spawn(true, [[3, 1, "m"], [5, 3, "m"], [2, 14, "m"], [5, 12, "m"]]),
+    () => spawn(false, [[1, 0, "m"], [4, 2, "m"], [3, 15, "m"], [6, 13, "m"]])
+  ],
+  running: [
+    () => running(0.22, 0, [[5, 2, "m"], [7, 1, "m"], [4, 13, "m"], [6, 14, "m"]]),
+    () => running(0.12, 1, [[3, 1, "m"], [6, 3, "m"], [5, 12, "m"], [3, 15, "m"]])
+  ],
+  waiting: [waiting(true), waiting(false)],
+  stalled: [stalled("e.e.e"), stalled("e"), stalled("e.e")],
+  report: [report(1, [".s.", "sss", ".s."]), report(1.25, ["s.s", ".s.", "s.s"]), report(1.1, [".s.", "sss", ".s."])],
+  gone: [() => digby(-0.3, { mound: "m" })]
+};
+var Z_LINES = [3, 2, 1, undefined];
+function idleArt(frame) {
+  const lines = cells(digby(-0.3, { top: frame !== undefined && breathesOut(frame) ? 8 : 6 }));
+  const line = Z_LINES[(frame ?? 0) % Z_LINES.length];
+  if (line === undefined)
+    return lines;
+  return lines.map((cellsOf, at) => at === line ? cellsOf.map((one, column) => column === 13 ? { char: "z", fg: "m" } : one) : cellsOf);
+}
+function art(state, frame) {
+  if (state === "idle")
+    return idleArt(frame);
+  const frames = ART[state];
+  return cells(frames[(frame ?? 0) % frames.length](!(frame !== undefined && OPEN_EYES.has(state) && blinks(frame))));
+}
 
 // src/tree/rpc.ts
-import { Rpc as Rpc2 } from "@opencode/plugin/rpc";
-import { Schema as Schema2 } from "effect";
-var Count2 = Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0));
-var Group = Schema2.Struct({ name: Schema2.String, reported: Count2, members: Count2 });
-var Summary = Schema2.Struct({
-  running: Count2,
-  waiting: Count2,
-  idle: Count2,
-  stalled: Schema2.optionalKey(Count2),
-  groups: Schema2.Array(Group)
+import { Rpc as Rpc3 } from "@opencode/plugin/rpc";
+import { Schema as Schema3 } from "effect";
+var Count3 = Schema3.Int.check(Schema3.isGreaterThanOrEqualTo(0));
+var Group = Schema3.Struct({ name: Schema3.String, reported: Count3, members: Count3 });
+var Summary = Schema3.Struct({
+  running: Count3,
+  waiting: Count3,
+  idle: Count3,
+  stalled: Schema3.optionalKey(Count3),
+  groups: Schema3.Array(Group)
 });
-var Wait = Schema2.Union([
-  Schema2.Struct({ type: Schema2.Literal("permission"), action: Schema2.String, resources: Schema2.Array(Schema2.String) }),
-  Schema2.Struct({ type: Schema2.Literal("question"), question: Schema2.String }),
-  Schema2.Struct({ type: Schema2.Literal("form"), title: Schema2.String })
+var Wait = Schema3.Union([
+  Schema3.Struct({ type: Schema3.Literal("permission"), action: Schema3.String, resources: Schema3.Array(Schema3.String) }),
+  Schema3.Struct({ type: Schema3.Literal("question"), question: Schema3.String }),
+  Schema3.Struct({ type: Schema3.Literal("form"), title: Schema3.String })
 ]);
-var Row = Schema2.Struct({
-  sessionID: Schema2.String,
-  parentID: Schema2.String,
-  title: Schema2.String,
-  depth: Count2,
-  state: Schema2.Literals(["running", "waiting", "idle", "stalled", "gone"]),
-  stalled: Schema2.optionalKey(Schema2.Number),
-  outcome: Schema2.optionalKey(Schema2.Literals(["succeeded", "failed", "interrupted"])),
-  stopped: Schema2.optionalKey(Schema2.Boolean),
-  report: Schema2.optionalKey(Schema2.Struct({ state: Schema2.Literals(["owed", "reported", "ended"]), status: Schema2.optionalKey(Schema2.String), progressed: Schema2.Boolean })),
-  group: Schema2.optionalKey(Schema2.Struct({ name: Schema2.String, standing: Schema2.String })),
-  isolated: Schema2.Boolean,
-  created: Schema2.Number,
-  idle: Schema2.optionalKey(Schema2.Number),
-  cost: Schema2.optionalKey(Schema2.Number),
-  tool: Schema2.optionalKey(Schema2.Struct({ name: Schema2.String, at: Schema2.Number })),
-  waits: Schema2.Array(Wait)
+var Row = Schema3.Struct({
+  sessionID: Schema3.String,
+  parentID: Schema3.String,
+  title: Schema3.String,
+  depth: Count3,
+  state: Schema3.Literals(["running", "waiting", "idle", "stalled", "gone"]),
+  stalled: Schema3.optionalKey(Schema3.Number),
+  outcome: Schema3.optionalKey(Schema3.Literals(["succeeded", "failed", "interrupted"])),
+  stopped: Schema3.optionalKey(Schema3.Boolean),
+  report: Schema3.optionalKey(Schema3.Struct({ state: Schema3.Literals(["owed", "reported", "ended"]), status: Schema3.optionalKey(Schema3.String), progressed: Schema3.Boolean })),
+  group: Schema3.optionalKey(Schema3.Struct({ name: Schema3.String, standing: Schema3.String })),
+  isolated: Schema3.Boolean,
+  created: Schema3.Number,
+  idle: Schema3.optionalKey(Schema3.Number),
+  cost: Schema3.optionalKey(Schema3.Number),
+  context: Schema3.optionalKey(Schema3.Number),
+  tool: Schema3.optionalKey(Schema3.Struct({ name: Schema3.String, at: Schema3.Number })),
+  waits: Schema3.Array(Wait)
 });
-var Tree = Schema2.Struct({
-  rows: Schema2.Array(Row),
-  truncated: Schema2.optionalKey(Count2),
-  stalled: Schema2.optionalKey(Schema2.Number)
+var Tree = Schema3.Struct({
+  rows: Schema3.Array(Row),
+  truncated: Schema3.optionalKey(Count3),
+  stalled: Schema3.optionalKey(Schema3.Number)
 });
-var Stopped = Schema2.Struct({
-  stopped: Schema2.Array(Schema2.Struct({ sessionID: Schema2.String, title: Schema2.String, outcome: Schema2.String })),
-  cancelled: Count2
+var Stopped = Schema3.Struct({
+  stopped: Schema3.Array(Schema3.Struct({ sessionID: Schema3.String, title: Schema3.String, outcome: Schema3.String })),
+  cancelled: Count3
 });
-var Forgotten = Schema2.Union([
-  Schema2.Struct({ outcome: Schema2.Literals(["forgotten", "removed", "gone"]) }),
-  Schema2.Struct({ outcome: Schema2.Literal("kept"), reason: Schema2.String })
+var Forgotten2 = Schema3.Union([
+  Schema3.Struct({ outcome: Schema3.Literals(["forgotten", "removed", "gone"]) }),
+  Schema3.Struct({ outcome: Schema3.Literal("kept"), reason: Schema3.String })
 ]);
-var treeRpc = Rpc2.define({
+var treeRpc = Rpc3.define({
   id: "courier",
   methods: {
     summary: {
-      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String })),
-      output: Schema2.toStandardSchemaV1(Summary)
+      input: Schema3.toStandardSchemaV1(Schema3.Struct({ sessionID: Schema3.String })),
+      output: Schema3.toStandardSchemaV1(Summary)
     },
     tree: {
-      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String })),
-      output: Schema2.toStandardSchemaV1(Tree)
+      input: Schema3.toStandardSchemaV1(Schema3.Struct({ sessionID: Schema3.String })),
+      output: Schema3.toStandardSchemaV1(Tree)
     },
     stop: {
-      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String, by: Schema2.String })),
-      output: Schema2.toStandardSchemaV1(Stopped),
-      errors: { refused: Schema2.toStandardSchemaV1(Schema2.Struct({})) }
+      input: Schema3.toStandardSchemaV1(Schema3.Struct({ sessionID: Schema3.String, by: Schema3.String })),
+      output: Schema3.toStandardSchemaV1(Stopped),
+      errors: { refused: Schema3.toStandardSchemaV1(Schema3.Struct({})) }
     },
     cleanup: {
-      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String, by: Schema2.String })),
-      output: Schema2.toStandardSchemaV1(Forgotten),
-      errors: { refused: Schema2.toStandardSchemaV1(Schema2.Struct({})) }
+      input: Schema3.toStandardSchemaV1(Schema3.Struct({ sessionID: Schema3.String, by: Schema3.String })),
+      output: Schema3.toStandardSchemaV1(Forgotten2),
+      errors: { refused: Schema3.toStandardSchemaV1(Schema3.Struct({})) }
     }
   },
   events: {}
@@ -879,6 +1440,176 @@ var SETTLE_MS2 = 250;
 var PANEL_SETTLE_MS = 1000;
 var PANEL = "courier-tree";
 var TICK_MS = 1000;
+var FRAME_MS = 90;
+var FLASH_MS = 1500;
+var BAR_MS = 450;
+function animationsOn(options) {
+  return options?.animations !== false;
+}
+function createMotion(enabled) {
+  const [frame, setFrame] = createSignal(0);
+  const [keepers, setKeepers] = createSignal([]);
+  const [moving, setMoving] = createSignal([]);
+  const cadence = createMemo(() => {
+    if (!enabled)
+      return;
+    if (moving().length)
+      return 1;
+    const wanted = keepers().filter((one) => one.when());
+    return wanted.length ? Math.min(...wanted.map((one) => one.every)) : undefined;
+  });
+  createEffect(() => {
+    const every = cadence();
+    if (every === undefined)
+      return;
+    const timer = setInterval(() => batch(() => {
+      const now = untrack(moving);
+      for (const one of now)
+        one.step(FRAME_MS * every);
+      setFrame((count2) => count2 + every);
+      const left = now.filter((one) => !one.done());
+      if (left.length !== now.length)
+        setMoving(left);
+    }), FRAME_MS * every);
+    onCleanup(() => clearInterval(timer));
+  });
+  const tween = (from, to, duration2, ease) => {
+    if (!enabled || from === to)
+      return {
+        value: () => to,
+        done: () => true
+      };
+    const target = {
+      value: from
+    };
+    const timeline = new Timeline({
+      duration: duration2,
+      autoplay: false
+    });
+    timeline.add(target, {
+      duration: duration2,
+      ease,
+      value: to
+    });
+    timeline.play();
+    let elapsed = 0;
+    const one = {
+      value: () => {
+        frame();
+        return target.value;
+      },
+      done: () => {
+        frame();
+        return elapsed >= duration2;
+      },
+      step: (ms) => {
+        elapsed += ms;
+        timeline.update(ms);
+      }
+    };
+    setMoving((all) => [...all, one]);
+    return one;
+  };
+  return {
+    enabled,
+    frame,
+    animates: (when, every = 1) => setKeepers((all) => [...all, {
+      when,
+      every
+    }]),
+    tween
+  };
+}
+function createFlashes(motion, rows) {
+  const [flashes, setFlashes] = createSignal(new Map);
+  let seen;
+  createEffect(() => {
+    const read = rows();
+    const before = seen;
+    seen = new Map(read.map((row) => [row.sessionID, row.report?.state]));
+    if (!before || !motion.enabled)
+      return;
+    const arrived = read.filter((row) => row.report?.state === "reported" && before.has(row.sessionID) && before.get(row.sessionID) !== "reported");
+    if (!arrived.length)
+      return;
+    const next = new Map([...untrack(flashes)].filter(([, one]) => !untrack(one.done)));
+    for (const row of arrived)
+      next.set(row.sessionID, motion.tween(1, 0, FLASH_MS, "outQuad"));
+    setFlashes(next);
+  });
+  const strength = (sessionID) => {
+    const one = flashes().get(sessionID);
+    return one && !one.done() ? one.value() : 0;
+  };
+  const reported = () => [...flashes().values()].some((one) => !one.done());
+  return {
+    strength,
+    reported
+  };
+}
+function createBarFill(motion, counts) {
+  const target = createMemo(() => filledCells(counts()));
+  const [easing, setEasing] = createSignal();
+  let last;
+  createEffect(() => {
+    const cells2 = target();
+    const shown = counts().started > 0;
+    if (last && cells2 !== last.cells) {
+      const from = untrack(() => easing()?.value()) ?? last.cells;
+      setEasing(last.shown ? motion.tween(from, cells2, BAR_MS, "outQuad") : undefined);
+    }
+    last = {
+      cells: cells2,
+      shown
+    };
+  });
+  return () => easing()?.value() ?? target();
+}
+function createSpawns(motion, rows) {
+  const [hold, setHold] = createSignal();
+  let seen;
+  createEffect(() => {
+    const read = rows();
+    if (!read)
+      return;
+    const before = seen;
+    seen = new Set(read.map((row) => row.sessionID));
+    if (before && motion.enabled && read.some((row) => !before.has(row.sessionID)))
+      setHold(motion.tween(1, 0, FLASH_MS, "linear"));
+  });
+  return () => {
+    const one = hold();
+    return one !== undefined && !one.done();
+  };
+}
+function mascotState(rows, {
+  reported = false,
+  spawned = false
+} = {}) {
+  if (reported)
+    return "report";
+  if (spawned)
+    return "spawn";
+  if (rows.some((row) => row.state === "waiting"))
+    return "waiting";
+  if (rows.some((row) => row.state === "stalled"))
+    return "stalled";
+  if (rows.some((row) => row.state === "running"))
+    return "running";
+  return rows.length && rows.every((row) => row.state === "gone") ? "gone" : "idle";
+}
+function countsLine(rows) {
+  const count2 = (state) => rows.filter((row) => row.state === state).length;
+  return [count2("waiting") ? `${count2("waiting")} waiting on you` : "", count2("stalled") ? `${count2("stalled")} stalled` : "", count2("running") ? `${count2("running")} running` : "", count2("idle") ? `${count2("idle")} idle` : ""].filter(Boolean).join(" \xB7 ");
+}
+var GLYPH_ROWS = 12;
+var GLYPH_COLUMNS = 54;
+var ART_ROWS = 14;
+var BELOW_ROWS = 10;
+function blend(tint, rest, amount) {
+  const mix = (a, b) => b + (a - b) * amount;
+  return RGBA.fromValues(mix(tint.r, rest.r), mix(tint.g, rest.g), mix(tint.b, rest.b), mix(tint.a, rest.a));
+}
 function summaryLine(summary, maxWidth = Infinity) {
   const groups = summary.groups.map((group) => `group ${group.name} ${group.reported}/${group.members}`);
   const parts = [summary.waiting ? `${summary.waiting} waiting on you` : "", summary.stalled ? `${summary.stalled} stalled` : "", summary.running ? `${summary.running} running` : "", ...groups, summary.idle ? `${summary.idle} idle` : ""].filter(Boolean);
@@ -893,14 +1624,14 @@ function summaryLine(summary, maxWidth = Infinity) {
       return line(kept);
   return parts[0];
 }
-function duration(ms) {
+function duration2(ms) {
   const seconds = Math.max(0, Math.floor(ms / 1000));
-  const pad = (value) => String(value).padStart(2, "0");
+  const pad2 = (value) => String(value).padStart(2, "0");
   if (seconds < 60)
     return `${seconds}s`;
   if (seconds < 3600)
-    return `${Math.floor(seconds / 60)}m ${pad(seconds % 60)}s`;
-  return `${Math.floor(seconds / 3600)}h ${pad(Math.floor(seconds / 60) % 60)}m`;
+    return `${Math.floor(seconds / 60)}m ${pad2(seconds % 60)}s`;
+  return `${Math.floor(seconds / 3600)}h ${pad2(Math.floor(seconds / 60) % 60)}m`;
 }
 function parts(rows, parentID) {
   const children = rows.filter((row) => row.parentID === parentID);
@@ -909,12 +1640,15 @@ function parts(rows, parentID) {
     started: children.length
   };
 }
-function bar({
+function filledCells({
   reported,
   started
 }, width = 10) {
-  const filled = started ? Math.round(reported / started * width) : 0;
-  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}] ${reported}/${started} reported`;
+  return started ? Math.round(reported / started * width) : 0;
+}
+function bar(counts, width = 10, filled = filledCells(counts, width)) {
+  const cells2 = Math.max(0, Math.min(width, Math.round(filled)));
+  return `[${"\u2588".repeat(cells2)}${"\u2591".repeat(width - cells2)}] ${counts.reported}/${counts.started} reported`;
 }
 function waitLine(wait) {
   if (wait.type === "permission")
@@ -922,7 +1656,66 @@ function waitLine(wait) {
   return wait.type === "form" ? `shows a form: ${wait.title}` : `asks: ${wait.question}`;
 }
 function statusLine(row) {
-  return [stateWord(row), reportWords(row.report, row.stopped), row.group ? `group ${row.group.name} ${row.group.standing}` : "", row.isolated ? "isolated" : ""].filter(Boolean).join(" \xB7 ");
+  return statusParts(row).map((part) => part.text).join(" \xB7 ");
+}
+function statusParts(row) {
+  const parts2 = [{
+    text: stateWord(row),
+    kind: "state"
+  }, {
+    text: reportWords(row.report, row.stopped),
+    kind: "report"
+  }, {
+    text: row.group ? `group ${row.group.name} ${row.group.standing}` : "",
+    kind: "plain"
+  }, {
+    text: row.isolated ? "isolated" : "",
+    kind: "plain"
+  }];
+  return parts2.filter((part) => part.text);
+}
+var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function rowMark(row, theme, frame) {
+  const {
+    error,
+    warning,
+    success,
+    info
+  } = theme.text.feedback;
+  if (row.state === "gone")
+    return {
+      mark: " ",
+      color: undefined
+    };
+  if (row.state === "stalled")
+    return {
+      mark: "!",
+      color: error.base
+    };
+  if (row.state === "waiting")
+    return {
+      mark: "\u25CF",
+      color: warning.base
+    };
+  if (row.state === "running")
+    return {
+      mark: frame === undefined ? "\u2022" : SPINNER[frame % SPINNER.length],
+      color: info.base
+    };
+  if (!row.stopped && (row.outcome === "failed" || row.outcome === "interrupted"))
+    return {
+      mark: "\u2717",
+      color: error.base
+    };
+  if (row.report?.state === "reported")
+    return {
+      mark: "\u2713",
+      color: success.base
+    };
+  return {
+    mark: " ",
+    color: undefined
+  };
 }
 function stateWord(row) {
   if (row.state === "waiting")
@@ -935,21 +1728,23 @@ function stateWord(row) {
     return row.outcome;
   return row.state;
 }
-function reportWords(report, stopped) {
-  if (!report)
+function reportWords(report2, stopped) {
+  if (!report2)
     return "";
-  if (report.state === "owed")
+  if (report2.state === "owed")
     return "owes a report";
-  if (report.state === "ended")
+  if (report2.state === "ended")
     return stopped ? "" : "ended without a report";
-  return ["reported", report.status].filter(Boolean).join(" ");
+  return ["reported", report2.status].filter(Boolean).join(" ");
 }
-var counted = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
-function activityLine(row, now) {
-  return [`ran ${duration((row.idle ?? now) - row.created)}`, row.tool ? `last ${row.tool.name} ${duration(now - row.tool.at)} ago` : "no tool call yet", row.cost !== undefined ? `$${row.cost.toFixed(2)}` : ""].filter(Boolean).join(" \xB7 ");
+var counted = (count2, noun) => `${count2} ${noun}${count2 === 1 ? "" : "s"}`;
+var CONTEXT_WARN = 0.8;
+function activityParts(row, now) {
+  return [`ran ${duration2((row.idle ?? now) - row.created)}`, row.tool ? `last ${row.tool.name} ${duration2(now - row.tool.at)} ago` : "no tool call yet", row.context !== undefined ? `ctx ${Math.round(row.context * 100)}%` : "", row.cost !== undefined ? `$${row.cost.toFixed(2)}` : ""].filter(Boolean);
 }
+var activityLine = (row, now) => activityParts(row, now).join(" \xB7 ");
 function stalledLine(since, now) {
-  return `a message waits in its inbox since ${duration(now - since)}, woken again in vain`;
+  return `a message waits in its inbox since ${duration2(now - since)}, woken again in vain`;
 }
 function detailLines(row, rows, now) {
   const started = parts(rows, row.sessionID);
@@ -972,7 +1767,7 @@ function courierOf(ctx) {
 var REREAD_MS = 15000;
 function changes(ctx, types, settle) {
   const [changed, setChanged] = createSignal(0);
-  const reread = setInterval(() => setChanged((count) => count + 1), REREAD_MS);
+  const reread = setInterval(() => setChanged((count2) => count2 + 1), REREAD_MS);
   let settling;
   const unlisten = ctx.data.listen(({
     details
@@ -981,7 +1776,7 @@ function changes(ctx, types, settle) {
       return;
     settling = setTimeout(() => {
       settling = undefined;
-      setChanged((count) => count + 1);
+      setChanged((count2) => count2 + 1);
     }, settle);
   });
   return [changed, () => {
@@ -1107,8 +1902,8 @@ async function confirmStop(ctx, courier, location, by, target) {
   }
   return true;
 }
-function forgottenLine(title, result) {
-  const name = `"${oneLine(title)}"`;
+function forgottenLine2(title, result) {
+  const name = `"${oneLine3(title)}"`;
   if (result.outcome === "kept")
     return `Kept ${name} and its worktree: ${result.reason}`;
   if (result.outcome === "removed")
@@ -1119,7 +1914,7 @@ async function confirmForget(ctx, courier, location, by, target, done) {
   const what = target.isolated ? "Its worktree is removed unless it has uncommitted changes or commits found nowhere else." : "It leaves this tree and courier_children.";
   const confirmed = await ctx.ui.dialog.confirm({
     title: "Forget session",
-    message: `Forget "${oneLine(target.title)}" (${target.sessionID})? ${what}`,
+    message: `Forget "${oneLine3(target.title)}" (${target.sessionID})? ${what}`,
     label: {
       confirm: "Forget",
       cancel: "Keep"
@@ -1136,7 +1931,7 @@ async function confirmForget(ctx, courier, location, by, target, done) {
     });
     ctx.ui.toast.show({
       title: "courier",
-      message: forgottenLine(target.title, result),
+      message: forgottenLine2(target.title, result),
       variant: result.outcome === "kept" ? "warning" : "success"
     });
     if (result.outcome !== "kept")
@@ -1152,7 +1947,25 @@ async function confirmForget(ctx, courier, location, by, target, done) {
 }
 var FOCUS_PROMPT = "pane.focus.left";
 var SPLIT_WIDTH = 108;
-var oneLine = (title) => title.replace(/[\r\n]+/g, " ");
+var oneLine3 = (title) => title.replace(/[\r\n]+/g, " ");
+var digbyColours = (theme) => ({
+  b: theme.text.base,
+  k: theme.background.base,
+  g: theme.background.raised.max,
+  m: theme.text.muted,
+  a: theme.text.action.primary.selected,
+  w: theme.text.feedback.warning.base,
+  e: theme.text.feedback.error.base,
+  s: theme.text.feedback.success.base
+});
+function restBackground(theme, {
+  selected,
+  hovered
+}) {
+  if (selected)
+    return theme.background.raised.high;
+  return hovered ? theme.background.raised.base : undefined;
+}
 function TreePanel(props) {
   const {
     ctx,
@@ -1246,13 +2059,25 @@ function TreePanel(props) {
     if (next)
       setSelectedID(next.sessionID);
   };
+  const openRow = (row) => ctx.ui.router.navigate({
+    type: "session",
+    sessionID: row.sessionID
+  });
   const open = () => {
     const row = current();
     if (row)
-      ctx.ui.router.navigate({
-        type: "session",
-        sessionID: row.sessionID
-      });
+      openRow(row);
+  };
+  const [hovered, setHovered] = createSignal();
+  createEffect(() => {
+    const id = hovered();
+    if (id !== undefined && !rows().some((row) => row.sessionID === id))
+      setHovered(undefined);
+  });
+  let pressed;
+  const click = (row) => {
+    setSelectedID(row.sessionID);
+    openRow(row);
   };
   const stopSelected = () => {
     const row = current();
@@ -1270,7 +2095,7 @@ function TreePanel(props) {
     if (row.state !== "gone")
       return ctx.ui.toast.show({
         title: "courier",
-        message: `x forgets only a gone session; "${oneLine(row.title)}" is ${row.state}.`,
+        message: `x forgets only a gone session; "${oneLine3(row.title)}" is ${row.state}.`,
         variant: "warning"
       });
     confirmForget(ctx, courier, location, view.root, {
@@ -1335,6 +2160,61 @@ function TreePanel(props) {
     }]
   }));
   const root = () => parts(rows(), view.root);
+  const motion = createMotion(props.animations);
+  motion.animates(() => rows().some((row) => row.state === "running"));
+  const flashes = createFlashes(motion, rows);
+  const filled = createBarFill(motion, root);
+  const frame = () => motion.enabled ? motion.frame() : undefined;
+  const spawned = createSpawns(motion, () => latest()?.tree?.rows);
+  const [size, setSize] = createSignal({
+    width: 0,
+    height: 0
+  });
+  const height = () => size().height;
+  const empty = () => Boolean(latest()?.tree && !rows().length);
+  const glyphShown = () => height() >= GLYPH_ROWS && size().width >= GLYPH_COLUMNS;
+  const artShown = () => empty() && height() >= ART_ROWS;
+  const [listHeight, setListHeight] = createSignal(0);
+  const treeLines = () => rows().reduce((lines, row) => lines + 1 + detailLines(row, rows(), now()).length, 0);
+  const belowShown = () => rows().length > 0 && listHeight() - treeLines() >= BELOW_ROWS;
+  const headerGlyph = () => glyphShown() && !artShown() && !belowShown();
+  const mascot = createMemo(() => mascotState(rows(), {
+    reported: flashes.reported(),
+    spawned: spawned()
+  }));
+  motion.animates(() => (glyphShown() || artShown() || belowShown()) && mascot() !== "gone", MASCOT_EVERY);
+  const mascotFrame = () => motion.enabled ? Math.floor(motion.frame() / MASCOT_EVERY) : undefined;
+  const header = createMemo(() => cells(glyph(mascot(), mascotFrame())));
+  const art2 = createMemo(() => art(mascot(), mascotFrame()));
+  const tokens = digbyColours(theme);
+  const drawn = (line) => (() => {
+    var _el$4 = _$createElement("text");
+    _$setProp(_el$4, "wrapMode", "none");
+    _$setProp(_el$4, "flexShrink", 0);
+    _$insert(_el$4, _$createComponent(Index, {
+      get each() {
+        return line();
+      },
+      children: (one) => (() => {
+        var _el$5 = _$createElement("span");
+        _$insert(_el$5, () => one().char);
+        _$effect((_$p) => _$setProp(_el$5, "style", {
+          fg: one().fg && tokens[one().fg],
+          bg: one().bg && tokens[one().bg]
+        }, _$p));
+        return _el$5;
+      })()
+    }));
+    return _el$4;
+  })();
+  const rowBackground = (row, chosen) => {
+    const rest = restBackground(theme, {
+      selected: chosen && input.focused,
+      hovered: hovered() === row.sessionID
+    });
+    const strength = flashes.strength(row.sessionID);
+    return strength > 0 ? blend(theme.background.feedback.success.base, rest ?? theme.background.base, strength) : rest;
+  };
   const rowColor = (row) => {
     if (row.state === "stalled")
       return theme.text.feedback.error.base;
@@ -1342,84 +2222,153 @@ function TreePanel(props) {
       return theme.text.feedback.warning.base;
     return row.state === "gone" ? theme.text.muted : theme.text.base;
   };
+  const partColor = (row, kind) => {
+    const marked = rowMark(row, theme);
+    if (kind === "state" && row.state === "running")
+      return marked.color;
+    if (kind === "report" && row.report?.state === "reported")
+      return theme.text.feedback.success.base;
+    return theme.text.muted;
+  };
   return (() => {
-    var _el$4 = _$createElement("box"), _el$5 = _$createElement("box"), _el$6 = _$createElement("text"), _el$15 = _$createElement("scrollbox"), _el$16 = _$createElement("text");
-    _$insertNode(_el$4, _el$5);
-    _$insertNode(_el$4, _el$15);
-    _$insertNode(_el$4, _el$16);
-    _$setProp(_el$4, "flexDirection", "column");
-    _$setProp(_el$4, "flexGrow", 1);
-    _$setProp(_el$4, "paddingLeft", 1);
-    _$setProp(_el$4, "paddingRight", 1);
-    _$insertNode(_el$5, _el$6);
-    _$setProp(_el$5, "flexDirection", "row");
-    _$setProp(_el$5, "flexShrink", 0);
-    _$setProp(_el$5, "gap", 2);
-    _$insertNode(_el$6, _$createTextNode(`courier tree`));
-    _$setProp(_el$6, "wrapMode", "none");
-    _$insert(_el$5, _$createComponent(Show, {
+    var _el$6 = _$createElement("box"), _el$7 = _$createElement("box"), _el$8 = _$createElement("text"), _el$20 = _$createElement("scrollbox"), _el$22 = _$createElement("text");
+    _$insertNode(_el$6, _el$7);
+    _$insertNode(_el$6, _el$20);
+    _$insertNode(_el$6, _el$22);
+    _$setProp(_el$6, "flexDirection", "column");
+    _$setProp(_el$6, "flexGrow", 1);
+    _$setProp(_el$6, "paddingLeft", 1);
+    _$setProp(_el$6, "paddingRight", 1);
+    _$setProp(_el$6, "onSizeChange", function() {
+      setSize({
+        width: this.width,
+        height: this.height
+      });
+    });
+    _$setProp(_el$6, "onMouseDrag", () => pressed = undefined);
+    _$insertNode(_el$7, _el$8);
+    _$setProp(_el$7, "flexDirection", "row");
+    _$setProp(_el$7, "flexShrink", 0);
+    _$setProp(_el$7, "gap", 2);
+    _$insert(_el$7, _$createComponent(Show, {
+      get when() {
+        return headerGlyph();
+      },
+      get children() {
+        return drawn(() => header()[0]);
+      }
+    }), _el$8);
+    _$insertNode(_el$8, _$createTextNode(`courier tree`));
+    _$setProp(_el$8, "wrapMode", "none");
+    _$insert(_el$7, _$createComponent(Show, {
       get when() {
         return root().started;
       },
       get children() {
-        var _el$8 = _$createElement("text");
-        _$setProp(_el$8, "wrapMode", "none");
-        _$insert(_el$8, () => bar(root()));
-        _$effect((_$p) => _$setProp(_el$8, "fg", theme.text.muted, _$p));
-        return _el$8;
+        var _el$0 = _$createElement("text");
+        _$setProp(_el$0, "wrapMode", "none");
+        _$insert(_el$0, () => bar(root(), 10, filled()));
+        _$effect((_$p) => _$setProp(_el$0, "fg", tokens.a, _$p));
+        return _el$0;
       }
     }), null);
-    _$insert(_el$5, _$createComponent(Show, {
+    _$insert(_el$7, _$createComponent(Show, {
       get when() {
         return latest()?.tree?.truncated;
       },
       get children() {
-        var _el$9 = _$createElement("text"), _el$0 = _$createTextNode(` older left out`);
-        _$insertNode(_el$9, _el$0);
-        _$setProp(_el$9, "wrapMode", "none");
-        _$insert(_el$9, () => latest()?.tree?.truncated, _el$0);
-        _$effect((_$p) => _$setProp(_el$9, "fg", theme.text.feedback.warning.base, _$p));
-        return _el$9;
+        var _el$1 = _$createElement("text"), _el$10 = _$createTextNode(` older left out`);
+        _$insertNode(_el$1, _el$10);
+        _$setProp(_el$1, "wrapMode", "none");
+        _$insert(_el$1, () => latest()?.tree?.truncated, _el$10);
+        _$effect((_$p) => _$setProp(_el$1, "fg", theme.text.feedback.warning.base, _$p));
+        return _el$1;
       }
     }), null);
-    _$insert(_el$4, _$createComponent(Show, {
+    _$insert(_el$6, _$createComponent(Show, {
+      get when() {
+        return glyphShown();
+      },
+      get children() {
+        var _el$11 = _$createElement("box"), _el$12 = _$createElement("text");
+        _$insertNode(_el$11, _el$12);
+        _$setProp(_el$11, "flexDirection", "row");
+        _$setProp(_el$11, "flexShrink", 0);
+        _$setProp(_el$11, "gap", 2);
+        _$insert(_el$11, _$createComponent(Show, {
+          get when() {
+            return headerGlyph();
+          },
+          get children() {
+            return drawn(() => header()[1]);
+          }
+        }), _el$12);
+        _$setProp(_el$12, "wrapMode", "none");
+        _$insert(_el$12, () => countsLine(rows()));
+        _$effect((_$p) => _$setProp(_el$12, "fg", theme.text.muted, _$p));
+        return _el$11;
+      }
+    }), _el$20);
+    _$insert(_el$6, _$createComponent(Show, {
       get when() {
         return latest()?.error;
       },
       get children() {
-        var _el$1 = _$createElement("text"), _el$10 = _$createTextNode(`courier RPC failed: `);
-        _$insertNode(_el$1, _el$10);
-        _$insert(_el$1, () => latest()?.error, null);
-        _$effect((_$p) => _$setProp(_el$1, "fg", theme.text.feedback.error.base, _$p));
-        return _el$1;
+        var _el$13 = _$createElement("text"), _el$14 = _$createTextNode(`courier RPC failed: `);
+        _$insertNode(_el$13, _el$14);
+        _$insert(_el$13, () => latest()?.error, null);
+        _$effect((_$p) => _$setProp(_el$13, "fg", theme.text.feedback.error.base, _$p));
+        return _el$13;
       }
-    }), _el$15);
-    _$insert(_el$4, _$createComponent(Show, {
+    }), _el$20);
+    _$insert(_el$6, _$createComponent(Show, {
       get when() {
         return latest()?.tree?.stalled;
       },
       get children() {
-        var _el$11 = _$createElement("text"), _el$12 = _$createTextNode(`This session is stalled: `);
-        _$insertNode(_el$11, _el$12);
-        _$insert(_el$11, () => stalledLine(latest().tree.stalled, now()), null);
-        _$effect((_$p) => _$setProp(_el$11, "fg", theme.text.feedback.error.base, _$p));
-        return _el$11;
+        var _el$15 = _$createElement("text"), _el$16 = _$createTextNode(`This session is stalled: `);
+        _$insertNode(_el$15, _el$16);
+        _$insert(_el$15, () => stalledLine(latest().tree.stalled, now()), null);
+        _$effect((_$p) => _$setProp(_el$15, "fg", theme.text.feedback.error.base, _$p));
+        return _el$15;
       }
-    }), _el$15);
-    _$insert(_el$4, _$createComponent(Show, {
+    }), _el$20);
+    _$insert(_el$6, _$createComponent(Show, {
       get when() {
         return _$memo(() => !!latest()?.tree)() && !rows().length;
       },
       get children() {
-        var _el$13 = _$createElement("text");
-        _$insertNode(_el$13, _$createTextNode(`No session started with courier_spawn under this one.`));
-        _$effect((_$p) => _$setProp(_el$13, "fg", theme.text.muted, _$p));
-        return _el$13;
+        return [(() => {
+          var _el$17 = _$createElement("text");
+          _$insertNode(_el$17, _$createTextNode(`No session started with courier_spawn under this one.`));
+          _$effect((_$p) => _$setProp(_el$17, "fg", theme.text.muted, _$p));
+          return _el$17;
+        })(), _$createComponent(Show, {
+          get when() {
+            return artShown();
+          },
+          get children() {
+            var _el$19 = _$createElement("box");
+            _$setProp(_el$19, "flexDirection", "column");
+            _$setProp(_el$19, "flexShrink", 0);
+            _$setProp(_el$19, "paddingTop", 1);
+            _$insert(_el$19, _$createComponent(Index, {
+              get each() {
+                return art2();
+              },
+              children: (line) => drawn(line)
+            }));
+            return _el$19;
+          }
+        })];
       }
-    }), _el$15);
-    _$use((value) => scroll = value, _el$15);
-    _$setProp(_el$15, "flexGrow", 1);
-    _$insert(_el$15, _$createComponent(For, {
+    }), _el$20);
+    _$use((value) => scroll = value, _el$20);
+    _$setProp(_el$20, "flexGrow", 1);
+    _$setProp(_el$20, "onSizeChange", function() {
+      setListHeight(this.height);
+    });
+    _$insert(_el$20, _$createComponent(For, {
       get each() {
         return rows();
       },
@@ -1427,77 +2376,165 @@ function TreePanel(props) {
         const chosen = () => index() === selected();
         const indent = "  ".repeat(row.depth - 1);
         return (() => {
-          var _el$18 = _$createElement("box"), _el$19 = _$createElement("box"), _el$20 = _$createElement("text"), _el$21 = _$createElement("text"), _el$22 = _$createTextNode(`  `);
-          _$insertNode(_el$18, _el$19);
-          _$setProp(_el$18, "flexDirection", "column");
-          _$setProp(_el$18, "flexShrink", 0);
-          _$insertNode(_el$19, _el$20);
-          _$insertNode(_el$19, _el$21);
-          _$setProp(_el$19, "flexDirection", "row");
-          _$setProp(_el$19, "flexShrink", 0);
-          _$setProp(_el$20, "wrapMode", "none");
-          _$setProp(_el$20, "flexShrink", 1);
-          _$setProp(_el$20, "minWidth", 0);
-          _$insert(_el$20, indent, null);
-          _$insert(_el$20, () => chosen() ? "\u25B8 " : "  ", null);
-          _$insert(_el$20, () => oneLine(row.title), null);
-          _$insert(_el$20, () => row.sessionID === input.sessionID ? " (on screen)" : "", null);
-          _$insertNode(_el$21, _el$22);
-          _$setProp(_el$21, "wrapMode", "none");
-          _$setProp(_el$21, "flexShrink", 0);
-          _$insert(_el$21, () => statusLine(row), null);
-          _$insert(_el$18, _$createComponent(For, {
+          var _el$24 = _$createElement("box"), _el$25 = _$createElement("box"), _el$26 = _$createElement("text"), _el$27 = _$createElement("text"), _el$28 = _$createTextNode(` `), _el$29 = _$createElement("text"), _el$30 = _$createElement("text");
+          _$insertNode(_el$24, _el$25);
+          _$setProp(_el$24, "flexDirection", "column");
+          _$setProp(_el$24, "flexShrink", 0);
+          _$setProp(_el$24, "onMouseOver", () => setHovered(row.sessionID));
+          _$setProp(_el$24, "onMouseOut", () => setHovered((id) => id === row.sessionID ? undefined : id));
+          _$setProp(_el$24, "onMouseDown", (event) => pressed = event.button === MouseButton.LEFT ? row.sessionID : undefined);
+          _$setProp(_el$24, "onMouseUp", (event) => {
+            if (event.button !== MouseButton.LEFT)
+              return;
+            event.stopPropagation();
+            const down = pressed;
+            pressed = undefined;
+            if (down === row.sessionID)
+              click(row);
+          });
+          _$insertNode(_el$25, _el$26);
+          _$insertNode(_el$25, _el$27);
+          _$insertNode(_el$25, _el$29);
+          _$insertNode(_el$25, _el$30);
+          _$setProp(_el$25, "flexDirection", "row");
+          _$setProp(_el$25, "flexShrink", 0);
+          _$setProp(_el$26, "wrapMode", "none");
+          _$setProp(_el$26, "flexShrink", 0);
+          _$insert(_el$26, indent, null);
+          _$insert(_el$26, () => chosen() ? "\u25B8 " : "  ", null);
+          _$insertNode(_el$27, _el$28);
+          _$setProp(_el$27, "wrapMode", "none");
+          _$setProp(_el$27, "flexShrink", 0);
+          _$insert(_el$27, () => rowMark(row, theme, frame()).mark, _el$28);
+          _$setProp(_el$29, "wrapMode", "none");
+          _$setProp(_el$29, "flexShrink", 1);
+          _$setProp(_el$29, "minWidth", 0);
+          _$insert(_el$29, () => oneLine3(row.title), null);
+          _$insert(_el$29, () => row.sessionID === input.sessionID ? " (on screen)" : "", null);
+          _$insertNode(_el$30, _$createTextNode(`  `));
+          _$setProp(_el$30, "wrapMode", "none");
+          _$setProp(_el$30, "flexShrink", 0);
+          _$insert(_el$25, _$createComponent(For, {
+            get each() {
+              return statusParts(row);
+            },
+            children: (part, at2) => [_$createComponent(Show, {
+              get when() {
+                return at2();
+              },
+              get children() {
+                var _el$32 = _$createElement("text");
+                _$insertNode(_el$32, _$createTextNode(` \xB7 `));
+                _$setProp(_el$32, "wrapMode", "none");
+                _$setProp(_el$32, "flexShrink", 0);
+                _$effect((_$p) => _$setProp(_el$32, "fg", theme.text.muted, _$p));
+                return _el$32;
+              }
+            }), (() => {
+              var _el$34 = _$createElement("text");
+              _$setProp(_el$34, "wrapMode", "none");
+              _$setProp(_el$34, "flexShrink", 0);
+              _$insert(_el$34, () => part.text);
+              _$effect((_$p) => _$setProp(_el$34, "fg", partColor(row, part.kind), _$p));
+              return _el$34;
+            })()]
+          }), null);
+          _$insert(_el$24, _$createComponent(For, {
             get each() {
               return detailLines(row, rows(), now());
             },
             children: (line) => (() => {
-              var _el$23 = _$createElement("text"), _el$24 = _$createTextNode(`    `);
-              _$insertNode(_el$23, _el$24);
-              _$setProp(_el$23, "wrapMode", "none");
-              _$insert(_el$23, indent, _el$24);
-              _$insert(_el$23, line, null);
-              _$effect((_$p) => _$setProp(_el$23, "fg", theme.text.muted, _$p));
-              return _el$23;
+              var _el$35 = _$createElement("text"), _el$36 = _$createTextNode(`    `);
+              _$insertNode(_el$35, _el$36);
+              _$setProp(_el$35, "wrapMode", "none");
+              _$insert(_el$35, indent, _el$36);
+              _$insert(_el$35, _$createComponent(Show, {
+                get when() {
+                  return _$memo(() => row.context !== undefined)() && Math.round(row.context * 100) > CONTEXT_WARN * 100;
+                },
+                fallback: line,
+                get children() {
+                  return _$createComponent(For, {
+                    get each() {
+                      return line.split(" \xB7 ");
+                    },
+                    children: (part, at2) => [_$memo(() => at2() ? " \xB7 " : ""), _$memo(() => _$memo(() => part === `ctx ${Math.round(row.context * 100)}%`)() ? (() => {
+                      var _el$37 = _$createElement("span");
+                      _$insert(_el$37, part);
+                      _$effect((_$p) => _$setProp(_el$37, "style", {
+                        fg: theme.text.feedback.warning.base
+                      }, _$p));
+                      return _el$37;
+                    })() : part)]
+                  });
+                }
+              }), null);
+              _$effect((_$p) => _$setProp(_el$35, "fg", theme.text.muted, _$p));
+              return _el$35;
             })()
           }), null);
           _$effect((_p$) => {
-            var _v$3 = `courier-row-${index()}`, _v$4 = chosen() && input.focused ? theme.background.raised.high : undefined, _v$5 = rowColor(row), _v$6 = theme.text.muted;
-            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$18, "id", _v$3, _p$.e));
-            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$18, "backgroundColor", _v$4, _p$.t));
-            _v$5 !== _p$.a && (_p$.a = _$setProp(_el$20, "fg", _v$5, _p$.a));
-            _v$6 !== _p$.o && (_p$.o = _$setProp(_el$21, "fg", _v$6, _p$.o));
+            var _v$3 = `courier-row-${index()}`, _v$4 = rowBackground(row, chosen()), _v$5 = rowColor(row), _v$6 = rowMark(row, theme).color, _v$7 = rowColor(row), _v$8 = theme.text.muted;
+            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$24, "id", _v$3, _p$.e));
+            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$24, "backgroundColor", _v$4, _p$.t));
+            _v$5 !== _p$.a && (_p$.a = _$setProp(_el$26, "fg", _v$5, _p$.a));
+            _v$6 !== _p$.o && (_p$.o = _$setProp(_el$27, "fg", _v$6, _p$.o));
+            _v$7 !== _p$.i && (_p$.i = _$setProp(_el$29, "fg", _v$7, _p$.i));
+            _v$8 !== _p$.n && (_p$.n = _$setProp(_el$30, "fg", _v$8, _p$.n));
             return _p$;
           }, {
             e: undefined,
             t: undefined,
             a: undefined,
-            o: undefined
+            o: undefined,
+            i: undefined,
+            n: undefined
           });
-          return _el$18;
+          return _el$24;
         })();
       }
-    }));
-    _$insertNode(_el$16, _$createTextNode(`\u2191\u2193 select \xB7 enter open \xB7 s stop \xB7 x forget \xB7 r refresh \xB7 f fullscreen \xB7 q close`));
-    _$setProp(_el$16, "wrapMode", "none");
-    _$setProp(_el$16, "flexShrink", 0);
+    }), null);
+    _$insert(_el$20, _$createComponent(Show, {
+      get when() {
+        return belowShown();
+      },
+      get children() {
+        var _el$21 = _$createElement("box");
+        _$setProp(_el$21, "flexDirection", "column");
+        _$setProp(_el$21, "flexShrink", 0);
+        _$setProp(_el$21, "paddingTop", 1);
+        _$insert(_el$21, _$createComponent(Index, {
+          get each() {
+            return art2();
+          },
+          children: (line) => drawn(line)
+        }));
+        return _el$21;
+      }
+    }), null);
+    _$insertNode(_el$22, _$createTextNode(`\u2191\u2193 select \xB7 enter open \xB7 s stop \xB7 x forget \xB7 r refresh \xB7 f fullscreen \xB7 q close`));
+    _$setProp(_el$22, "wrapMode", "none");
+    _$setProp(_el$22, "flexShrink", 0);
     _$effect((_p$) => {
-      var _v$ = theme.text.base, _v$2 = theme.text.muted;
-      _v$ !== _p$.e && (_p$.e = _$setProp(_el$6, "fg", _v$, _p$.e));
-      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$16, "fg", _v$2, _p$.t));
+      var _v$ = tokens.a, _v$2 = theme.text.muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$8, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$22, "fg", _v$2, _p$.t));
       return _p$;
     }, {
       e: undefined,
       t: undefined
     });
-    return _el$4;
+    return _el$6;
   })();
 }
 var USAGE = "/courier tree opens the session tree; /courier stop [session] stops a session and those under it";
-function addTreePanel(ctx) {
+var usageWith = (verbs) => [USAGE, ...Object.values(verbs).map((verb) => verb.usage)].join("; ");
+function addTreePanel(ctx, verbs = {}) {
   const {
     courier,
     location
   } = courierOf(ctx);
+  const animations = animationsOn(ctx.options);
   const [changed, stopListening] = changes(ctx, PANEL_CHANGES, PANEL_SETTLE_MS);
   let following;
   let attempt = 0;
@@ -1531,7 +2568,8 @@ function addTreePanel(ctx) {
           },
           courier,
           location,
-          changed
+          changed,
+          animations
         });
       }
     })
@@ -1557,7 +2595,7 @@ function addTreePanel(ctx) {
     return;
   });
   const follow = (from, sessionID) => {
-    const token = ++attempt;
+    const token2 = ++attempt;
     const under = (tree) => tree?.rows.some((row) => row.sessionID === sessionID) === true;
     Object.assign(from, {
       at: undefined,
@@ -1568,7 +2606,7 @@ function addTreePanel(ctx) {
     (async () => {
       const inside = await treeOf(from.root);
       const own = under(inside) ? undefined : await treeOf(sessionID);
-      if (token !== attempt || following !== from)
+      if (token2 !== attempt || following !== from)
         return;
       if (under(inside))
         show(from, sessionID, from.root, inside);
@@ -1682,7 +2720,7 @@ function addTreePanel(ctx) {
     commands: [{
       id: "courier.command",
       title: "Courier",
-      description: USAGE,
+      description: usageWith(verbs),
       group: "Courier",
       slash: {
         name: "courier",
@@ -1694,9 +2732,12 @@ function addTreePanel(ctx) {
           return openPanel();
         if (verb === "stop")
           return stopUnder(target);
+        const further = Object.hasOwn(verbs, verb) ? verbs[verb] : undefined;
+        if (further)
+          return further.run();
         ctx.ui.toast.show({
           title: "courier",
-          message: USAGE,
+          message: usageWith(verbs),
           variant: "warning"
         });
       }
@@ -1766,7 +2807,13 @@ var tui_default = Plugin.define({
   id: "courier.tui",
   setup: (ctx) => {
     const inbox = addAsksInbox(ctx, CHANGES);
-    const cleanups = [inbox.cleanup, addTreeStatus(ctx, (sessionID) => void inbox.open(sessionID)), addTreePanel(ctx), addTreeAttention(ctx)];
+    const memory = addMemoryView(ctx);
+    const cleanups = [inbox.cleanup, addTreeStatus(ctx, (sessionID) => void inbox.open(sessionID)), addTreePanel(ctx, {
+      memory: {
+        run: () => void memory.open(),
+        usage: MEMORY_USAGE
+      }
+    }), addTreeAttention(ctx)];
     return () => {
       for (const cleanup of cleanups.toReversed())
         cleanup();