opencode-courier 0.10.0 → 0.10.2

package/dist/tree/send.js

@@ -2,6 +2,7 @@ import { envelope, isStatus, STATUSES } from "../kernel/protocol.js";
 import { groupStanding, holdReport, membershipFor, unholdForBlocked } from "./group.js";
 import { childStore, groupStore } from "./store.js";
 import { reportBody } from "./text.js";
+import { noteSent } from "./wake.js";
 /**
  * Drops a message into another session's inbox; OpenCode wakes that session if it is idle. From a spawned session
  * to the one that started it, it is its report or its progress (`noteReport`); a group member's final report is held (`hold`).
@@ -17,13 +18,17 @@ export async function send(ports, from, input) {
         const held = noted?.member && status && status !== "blocked" ? await hold(ports, noted.member, { at: noted.at, status, message: input.message, ...(input.artifacts ? { artifacts: input.artifacts } : {}) }) : undefined;
         if (held)
             return { status, report: true, held };
+        const text = envelope(from, reportBody(input.message, input.artifacts), status ? { status } : {});
+        const description = `Message from ${from}`;
         const delivered = await ports.session.synthetic({
             sessionID: input.sessionID,
-            text: envelope(from, reportBody(input.message, input.artifacts), status ? { status } : {}),
-            description: `Message from ${from}`,
+            text,
+            description,
             metadata: { source: "courier", from, ...(status ? { status } : {}) },
             delivery: input.queue ? "queue" : "steer",
         });
+        // Watched now, not when OpenCode's enqueued event is handled: a spawn in the same step must count the child it wakes.
+        await noteSent(ports, { sessionID: input.sessionID, inboxID: delivered.id, text, description }).catch(() => undefined);
         // A blocked report, once delivered, is the member's latest word: an earlier report held for it would be stale.
         if (noted?.member && status === "blocked")
             await unholdForBlocked(groupStore(ports.storage), noted.member).catch(() => undefined);

package/dist/tree/status.d.ts

@@ -15,6 +15,7 @@ export declare function status(ports: CourierPorts, input: StatusInput): Promise
     outcome: "failed" | "interrupted" | "succeeded" | undefined;
     updated: number;
     idle: number | undefined;
+    archived: number | undefined;
     lastText: string | undefined;
     pending: readonly import("./ports.js").Pending[] | undefined;
 }>>;
@@ -38,6 +39,7 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
     outcome?: "failed" | "interrupted" | "succeeded" | undefined;
     updated?: number | undefined;
     idle?: number | undefined;
+    archived?: number | undefined;
     lastText?: string | undefined;
     pending?: readonly import("./ports.js").Pending[] | undefined;
 } | {
@@ -51,6 +53,7 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
     outcome?: "failed" | "interrupted" | "succeeded" | undefined;
     updated?: number | undefined;
     idle?: number | undefined;
+    archived?: number | undefined;
     lastText?: string | undefined;
     pending?: readonly import("./ports.js").Pending[] | undefined;
 } | {
@@ -88,6 +91,7 @@ export declare function described(ports: CourierPorts, entry: RosterEntry): Prom
     outcome?: "failed" | "interrupted" | "succeeded" | undefined;
     updated?: number | undefined;
     idle?: number | undefined;
+    archived?: number | undefined;
     lastText?: string | undefined;
     pending?: readonly import("./ports.js").Pending[] | undefined;
 } | {
@@ -101,6 +105,7 @@ export declare function described(ports: CourierPorts, entry: RosterEntry): Prom
     outcome?: "failed" | "interrupted" | "succeeded" | undefined;
     updated?: number | undefined;
     idle?: number | undefined;
+    archived?: number | undefined;
     lastText?: string | undefined;
     pending?: readonly import("./ports.js").Pending[] | undefined;
 } | {

package/dist/tree/status.js

@@ -17,6 +17,7 @@ export async function status(ports, input) {
         outcome: info.outcome,
         updated: info.time.updated,
         idle: info.time.idle,
+        archived: info.time.archived,
         lastText,
         pending: pending.length ? pending : undefined,
     });

package/dist/tree/subtree.d.ts

@@ -20,9 +20,12 @@ export declare function subtree(storage: RosterStorage, rootID: string, retentio
     nodes: Below[];
 }>;
 type Info = Awaited<ReturnType<Plugin.Context["session"]["get"]>>;
-/** A session of a tree as a read looks it up: OpenCode's info of it, if it still knows it, and what it waits on. */
+/** A session of a tree as a read looks it up: OpenCode's info of it, if it still knows it, whether it runs, and what it waits on. */
 export interface Looked extends Below {
     readonly info: Info | undefined;
+    readonly running: boolean;
+    /** When its last turn ended, if it does not run and that is known. */
+    readonly endedAt?: number;
     readonly pending: ReadonlyArray<Pending>;
     readonly forms: ReadonlyArray<ShownForm>;
 }
@@ -70,6 +73,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         outcome?: "failed" | "interrupted" | "succeeded" | undefined;
         updated?: number | undefined;
         idle?: number | undefined;
+        archived?: number | undefined;
         lastText?: string | undefined;
         pending?: readonly Pending[] | undefined;
     } | {
@@ -90,6 +94,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         outcome?: "failed" | "interrupted" | "succeeded" | undefined;
         updated?: number | undefined;
         idle?: number | undefined;
+        archived?: number | undefined;
         lastText?: string | undefined;
         pending?: readonly Pending[] | undefined;
     } | {

package/dist/tree/subtree.js

@@ -1,6 +1,7 @@
-import { busy, cut, isLive } from "./domain.js";
+import { cut, isLive } from "./domain.js";
 import { lastStatus, reportOf } from "./report.js";
 import { isExpired } from "./roster.js";
+import { turnOf } from "./running.js";
 import { described } from "./status.js";
 import { childStore } from "./store.js";
 /**
@@ -42,8 +43,10 @@ export async function lookUp(ports, rootID) {
             ports.pending(node.entry.sessionID).catch(() => []),
             ports.forms(node.entry.sessionID).catch(() => []),
         ]);
+        const turn = info === undefined ? undefined : await turnOf(ports.session, node.entry.sessionID, info.time);
+        const running = turn?.running ?? false;
         // A form outlives its session's turn only when its withdrawal was missed, as while no instance followed the events.
-        return { ...node, info, pending, forms: info && busy(info.time) ? forms : [] };
+        return { ...node, info, running, ...(turn?.endedAt !== undefined ? { endedAt: turn.endedAt } : {}), pending, forms: running ? forms : [] };
     }));
 }
 /**
@@ -54,7 +57,7 @@ export async function readTree(ports, rootID, max = ports.limits.maxTotal) {
     const children = childStore(ports.storage);
     const all = await Promise.all((await lookUp(ports, rootID)).map(async (node) => {
         const report = await reportOf(children, node.entry.sessionID).catch(() => undefined);
-        return { ...node, report, live: isLive(node.info?.time, node.pending.length + node.forms.length, report) };
+        return { ...node, report, live: isLive(node.info ? node.running : undefined, node.pending.length + node.forms.length, report) };
     }));
     const listing = cut(all.map((node) => ({ sessionID: node.entry.sessionID, parentID: node.entry.parentID, createdAt: node.entry.createdAt, live: node.live, node })), max);
     return { kept: listing.kept.map(({ node }) => node), leftOut: listing.leftOut };

package/dist/tree/summary.js

@@ -1,20 +1,19 @@
-import { busy } from "./domain.js";
 import { groupStandings } from "./group.js";
 import { groupStore } from "./store.js";
 import { lookUp } from "./subtree.js";
 import { stalledAmong } from "./wake.js";
 /**
  * What a session is doing: waiting on a request it made or a form it shows, stalled, running, or idle; undefined when
- * OpenCode no longer knows it. A message waiting in its inbox makes a stalled session look busy.
+ * OpenCode no longer knows it. A message waiting in its inbox is no turn (`runs`); a stalled one reads stalled.
  */
-function activity({ info, pending, forms, entry }, stalled) {
+function activity({ info, running, pending, forms, entry }, stalled) {
     if (!info)
         return undefined;
     if (pending.length || forms.length)
         return "waiting";
     if (stalled.has(entry.sessionID))
         return "stalled";
-    return busy(info.time) ? "running" : "idle";
+    return running ? "running" : "idle";
 }
 /**
  * Every session started under a session, counted by what it is doing (the session itself too, when it is stalled), and its

package/dist/tree/tui.d.ts

@@ -4,7 +4,10 @@ import { type Accessor } from "solid-js";
 import { type MascotState, type Token } from "./mascot.js";
 import { type Forgotten, type Row, type Stopped, type Summary, type Wait } from "./rpc.js";
 type Context = Plugin.Context;
-/** The events after which a summary may read differently: a turn started or ended, a request or form, a session made or removed. */
+/**
+ * The events after which a summary may read differently: a turn started or ended, a request or form, a session made, removed,
+ * archived or unarchived.
+ */
 export declare const CHANGES: Set<string>;
 /** How long after the first of a burst of changes the entry asks the server again. */
 export declare const SETTLE_MS = 250;

package/dist/tree/wake.d.ts

@@ -39,6 +39,16 @@ export interface Execution {
  * Returns whether it is watched, which one sent with `resume: false` is not.
  */
 export declare function watchWake(ports: WatchPorts, event: Enqueued): Promise<boolean>;
+/**
+ * Watches a message `courier_send` has just had enqueued, without waiting for its enqueued event, so the limits see a reported child woken
+ * for it at once; the event leaves this row be. Dropped again if the message is already stored, delivered before it was written.
+ */
+export declare function noteSent(ports: Pick<WatchPorts, "storage" | "session" | "now">, sent: {
+    readonly sessionID: string;
+    readonly inboxID: string;
+    readonly text: string;
+    readonly description?: string;
+}): Promise<void>;
 /** Stops watching a message once it is delivered or cancelled. */
 export declare function settleWake(ports: Pick<WatchPorts, "storage">, event: InboxSettled): Promise<void>;
 /** A turn started in a session: the messages waiting there are its to take. */
@@ -54,16 +64,24 @@ export declare function wakeEnded(ports: WatchPorts, event: Execution & {
 }): Promise<void>;
 /** Forgets the messages watched in a session's inbox: it was deleted, or stopped, which nothing is to wake again. */
 export declare function forgetWakes(ports: Pick<WatchPorts, "storage">, sessionID: string): Promise<void>;
-/** The ports the scheduler's tick wakes sessions through: what every hub member's `later` ports have. */
+/** The ports the scheduler's tick wakes sessions through: what every hub-v2 member's `later` ports have, whose session is its `ctx.session`. */
 export type WakePorts = GroupPorts & {
+    readonly session: Pick<WatchPorts["session"], "get" | "context">;
     readonly now: () => number;
 };
 /**
- * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, and flags
- * stalled one still waiting `WAKE_MS` later; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
+ * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, flags stalled one still
+ * waiting `WAKE_MS` later, and marks running one a turn it shows will take; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
  */
 export declare function wakeMissed(ports: WakePorts, claimed: Set<string>): Promise<void>;
 /** Whether a message has waited in an idle session past `WAKE_MS`, and since a wake again, if one was sent; a stalled one is done. */
 export declare function missed(wake: Wake, now: number): boolean;
+/**
+ * Whether a courier message sent with a wake waits undelivered in the session's inbox while it is idle, waiting or, unless
+ * `stalled` is false, stalled; one a running turn is to take is not counted, as `runs` says that turn runs.
+ */
+export declare function waitsInInbox(ports: Pick<WatchPorts, "storage">, sessionID: string, { stalled }?: {
+    stalled?: boolean | undefined;
+}): Promise<boolean>;
 /** The sessions among `sessionIDs` flagged stalled, each with when its oldest stalled message was enqueued. */
 export declare function stalledAmong(ports: Pick<WatchPorts, "storage">, sessionIDs: ReadonlyArray<string>): Promise<Map<string, number>>;

package/dist/tree/wake.js

@@ -1,8 +1,7 @@
+import { busy, endsIdle } from "./domain.js";
 import { wakeStore } from "./store.js";
 /** How long a courier message may wait in an idle session's inbox before its wake counts as missed. */
 export const WAKE_MS = 30_000;
-/** Whether a session's stored messages end with the marker of an ended turn; one with none yet is taken to run. */
-const endsIdle = (messages) => messages.at(-1)?.type === "idle";
 /**
  * Watches a courier message enqueued for a session until it is delivered, noting whether the session runs.
  * Returns whether it is watched, which one sent with `resume: false` is not.
@@ -16,19 +15,30 @@ export async function watchWake(ports, event) {
     if (payload.metadata.resume === false)
         return false;
     const at = event.created ?? ports.now();
-    // Read after the enqueue: a turn it started has stored messages since, and an unknown session is taken to run.
-    const idle = await ports.session.context({ sessionID }).then(endsIdle, () => false);
-    await wakeStore(ports.storage).put({
-        sessionID,
-        inboxID,
-        at,
-        text: payload.text,
-        ...(typeof payload.description === "string" ? { description: payload.description } : {}),
-        running: !idle,
-        ...(idle ? { idleAt: at } : {}),
-    });
+    // A row `noteSent` wrote already is kept: it may have moved on since, and is no later than this one.
+    if ((await wakeStore(ports.storage).of(sessionID)).some((wake) => wake.inboxID === inboxID))
+        return true;
+    await watch(ports, { sessionID, inboxID, at, text: payload.text, ...(typeof payload.description === "string" ? { description: payload.description } : {}) });
     return true;
 }
+/**
+ * Watches a message `courier_send` has just had enqueued, without waiting for its enqueued event, so the limits see a reported child woken
+ * for it at once; the event leaves this row be. Dropped again if the message is already stored, delivered before it was written.
+ */
+export async function noteSent(ports, sent) {
+    const store = wakeStore(ports.storage);
+    if ((await store.of(sent.sessionID)).some((wake) => wake.inboxID === sent.inboxID))
+        return;
+    await watch(ports, { ...sent, at: ports.now() });
+    const stored = await ports.session.context({ sessionID: sent.sessionID }).then((messages) => messages.some((message) => message.id === sent.inboxID), () => false);
+    if (stored)
+        await store.remove(sent.sessionID, sent.inboxID);
+}
+async function watch(ports, wake) {
+    // Read after the enqueue: a turn it started has stored messages since, and an unknown session is taken to run.
+    const idle = await ports.session.context({ sessionID: wake.sessionID }).then(endsIdle, () => false);
+    await wakeStore(ports.storage).put({ ...wake, running: !idle, ...(idle ? { idleAt: wake.at } : {}) });
+}
 /** Stops watching a message once it is delivered or cancelled. */
 export async function settleWake(ports, event) {
     await wakeStore(ports.storage).remove(event.data.sessionID, event.data.inboxID);
@@ -44,15 +54,18 @@ export async function wakeStarted(ports, event) {
  * subscription; one still waiting is watched as waiting in an idle session from now.
  */
 export async function wakeEnded(ports, event) {
-    if (event.data.reason === "shutdown")
-        return;
     const { sessionID } = event.data;
     const store = wakeStore(ports.storage);
     const waiting = await store.of(sessionID);
     if (!waiting.length)
         return;
     const at = event.created ?? ports.now();
-    const stored = new Set((await ports.session.context({ sessionID }).catch(() => [])).map((message) => message.id));
+    const messages = await ports.session.context({ sessionID }).catch(() => []);
+    // A plain decline reports a shutdown after the aborted step that ends its turn; a real one between steps ends none. One during a
+    // step reads as ended too, until the turn the next boot resumes is seen to start or `wakeAgain` finds it running.
+    if (event.data.reason === "shutdown" && !endsIdle(messages))
+        return;
+    const stored = new Set(messages.map((message) => message.id));
     await Promise.all(waiting.map((wake) => (stored.has(wake.inboxID) ? store.remove(sessionID, wake.inboxID) : store.put({ ...wake, running: false, idleAt: at }))));
 }
 /** Forgets the messages watched in a session's inbox: it was deleted, or stopped, which nothing is to wake again. */
@@ -61,8 +74,8 @@ export async function forgetWakes(ports, sessionID) {
     await Promise.all((await store.of(sessionID)).map((wake) => store.remove(sessionID, wake.inboxID)));
 }
 /**
- * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, and flags
- * stalled one still waiting `WAKE_MS` later; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
+ * Sends once more, under its inbox id, each courier message an idle session has left waiting for `WAKE_MS`, flags stalled one still
+ * waiting `WAKE_MS` later, and marks running one a turn it shows will take; run by the scheduler's owner, `claimed` keeping a tick alongside off it.
  */
 export async function wakeMissed(ports, claimed) {
     const store = wakeStore(ports.storage);
@@ -86,6 +99,11 @@ async function wakeAgain(ports, store, wake, now) {
         const current = (await store.of(wake.sessionID)).find((one) => one.inboxID === wake.inboxID);
         if (!current || !missed(current, now))
             return;
+        // A shutdown during a step reads as an end, and the turn the next boot resumes may start unseen: that turn takes the message.
+        if (await runsNow(ports, wake.sessionID)) {
+            const { idleAt: _, ...running } = current;
+            return await store.put({ ...running, running: true });
+        }
         if (current.rewoken !== undefined) {
             ports.log(`courier wake: ${wake.sessionID} has not taken message ${wake.inboxID} since it was woken again; flagged stalled`);
             return await store.put({ ...current, stalled: now });
@@ -109,6 +127,21 @@ async function wakeAgain(ports, store, wake, now) {
         ports.log(`courier wake: could not wake ${wake.sessionID} again for ${wake.inboxID}: ${String(error)}`);
     }
 }
+/** Whether a session shows a turn running, by its times and its transcript read now; one that cannot be read does not, and is woken again. */
+async function runsNow(ports, sessionID) {
+    const info = await ports.session.get({ sessionID }).catch(() => undefined);
+    if (!info || !busy(info.time))
+        return false;
+    const messages = await ports.session.context({ sessionID }).catch(() => []);
+    return messages.length > 0 && !endsIdle(messages);
+}
+/**
+ * Whether a courier message sent with a wake waits undelivered in the session's inbox while it is idle, waiting or, unless
+ * `stalled` is false, stalled; one a running turn is to take is not counted, as `runs` says that turn runs.
+ */
+export async function waitsInInbox(ports, sessionID, { stalled = true } = {}) {
+    return (await wakeStore(ports.storage).of(sessionID)).some((wake) => !wake.running && (stalled || wake.stalled === undefined));
+}
 /** The sessions among `sessionIDs` flagged stalled, each with when its oldest stalled message was enqueued. */
 export async function stalledAmong(ports, sessionIDs) {
     const wanted = new Set(sessionIDs);

package/dist/tui.js

@@ -312,7 +312,7 @@ function addMemoryView(ctx) {
     } : chosen(value)), requested]);
   }
   const showList = (read, current) => {
-    const open2 = openSession();
+    const open = openSession();
     const now = Date.now();
     return show({
       title: `Memory (${read.records.length})`,
@@ -321,7 +321,7 @@ function addMemoryView(ctx) {
         current
       } : {},
       options: read.records.map((record) => ({
-        title: recordTitle(record, open2),
+        title: recordTitle(record, open),
         value: record,
         category: recordCategory(record, now),
         description: recordDescription(record),
@@ -865,12 +865,12 @@ function addAsksInbox(ctx, follows) {
     } = ask;
     const answers = [];
     for (const [index, prompt] of question.questions.entries()) {
-      const count2 = question.questions.length > 1 ? ` (${index + 1}/${question.questions.length})` : "";
+      const count = 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}${count2}`, choices, {
+      const picked = await choose(`${prompt.header}: ${prompt.question}${count}`, choices, {
         multiple: !!prompt.multiple,
         own: true
       });
@@ -1025,26 +1025,26 @@ function addAsksInbox(ctx, follows) {
     const {
       form
     } = ask;
-    const answer2 = {};
+    const answer = {};
     for (const field of form.fields) {
-      if (!active(field, answer2))
+      if (!active(field, answer))
         continue;
       if ("hidden" in field && field.hidden) {
         if ("default" in field && field.default !== undefined)
-          answer2[field.key] = field.default;
+          answer[field.key] = field.default;
         continue;
       }
       const value = await answerField(form, field);
       if (value === undefined)
         return false;
       if (value !== SKIP)
-        answer2[field.key] = value;
+        answer[field.key] = value;
     }
     try {
       await ctx.client.session.form.reply({
         sessionID: form.sessionID,
         formID: form.id,
-        answer: answer2
+        answer
       });
     } catch (error) {
       const tag = error?._tag;
@@ -1116,8 +1116,8 @@ function addAsksInbox(ctx, follows) {
     try {
       return await Promise.race([choosing.then((chosen) => ({
         chosen
-      })), newer.then((read2) => ({
-        read: read2
+      })), newer.then((read) => ({
+        read
       }))]);
     } finally {
       listing = undefined;
@@ -1502,7 +1502,7 @@ var treeRpc = Rpc3.define({
 });
 
 // src/tree/tui.tsx
-var CHANGES = new Set(["session.created", "session.deleted", "session.status", "session.idle", "session.execution.started", "session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.inbox.delivered", "session.synthetic", "permission.asked", "permission.replied", "form.created", "form.replied", "form.cancelled"]);
+var CHANGES = new Set(["session.created", "session.deleted", "session.status", "session.idle", "session.execution.started", "session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.inbox.delivered", "session.synthetic", "session.archived", "session.unarchived", "permission.asked", "permission.replied", "form.created", "form.replied", "form.cancelled"]);
 var PANEL_CHANGES = new Set([...CHANGES, "session.tool.called", "session.tool.success", "session.tool.failed", "session.usage.updated", "session.renamed"]);
 var SETTLE_MS2 = 250;
 var PANEL_SETTLE_MS = 1000;
@@ -1534,14 +1534,14 @@ function createMotion(enabled) {
       const now = untrack(moving);
       for (const one of now)
         one.step(FRAME_MS * every);
-      setFrame((count2) => count2 + every);
+      setFrame((count) => count + 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) => {
+  const tween = (from, to, duration, ease) => {
     if (!enabled || from === to)
       return {
         value: () => to,
@@ -1551,11 +1551,11 @@ function createMotion(enabled) {
       value: from
     };
     const timeline = new Timeline({
-      duration: duration2,
+      duration,
       autoplay: false
     });
     timeline.add(target, {
-      duration: duration2,
+      duration,
       ease,
       value: to
     });
@@ -1568,7 +1568,7 @@ function createMotion(enabled) {
       },
       done: () => {
         frame();
-        return elapsed >= duration2;
+        return elapsed >= duration;
       },
       step: (ms) => {
         elapsed += ms;
@@ -1620,14 +1620,14 @@ function createBarFill(motion, counts) {
   const [easing, setEasing] = createSignal();
   let last;
   createEffect(() => {
-    const cells2 = target();
+    const cells = target();
     const shown = counts().started > 0;
-    if (last && cells2 !== last.cells) {
+    if (last && cells !== last.cells) {
       const from = untrack(() => easing()?.value()) ?? last.cells;
-      setEasing(last.shown ? motion.tween(from, cells2, BAR_MS, "outQuad") : undefined);
+      setEasing(last.shown ? motion.tween(from, cells, BAR_MS, "outQuad") : undefined);
     }
     last = {
-      cells: cells2,
+      cells,
       shown
     };
   });
@@ -1667,8 +1667,8 @@ function mascotState(rows, {
   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 ");
+  const count = (state) => rows.filter((row) => row.state === state).length;
+  return [count("waiting") ? `${count("waiting")} waiting on you` : "", count("stalled") ? `${count("stalled")} stalled` : "", count("running") ? `${count("running")} running` : "", count("idle") ? `${count("idle")} idle` : ""].filter(Boolean).join(" \xB7 ");
 }
 var GLYPH_ROWS = 12;
 var GLYPH_COLUMNS = 54;
@@ -1694,12 +1694,12 @@ function summaryLine(summary, maxWidth = Infinity) {
 }
 function duration2(ms) {
   const seconds = Math.max(0, Math.floor(ms / 1000));
-  const pad2 = (value) => String(value).padStart(2, "0");
+  const pad = (value) => String(value).padStart(2, "0");
   if (seconds < 60)
     return `${seconds}s`;
   if (seconds < 3600)
-    return `${Math.floor(seconds / 60)}m ${pad2(seconds % 60)}s`;
-  return `${Math.floor(seconds / 3600)}h ${pad2(Math.floor(seconds / 60) % 60)}m`;
+    return `${Math.floor(seconds / 60)}m ${pad(seconds % 60)}s`;
+  return `${Math.floor(seconds / 3600)}h ${pad(Math.floor(seconds / 60) % 60)}m`;
 }
 function parts(rows, parentID) {
   const children = rows.filter((row) => row.parentID === parentID);
@@ -1715,8 +1715,8 @@ function filledCells({
   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`;
+  const cells = Math.max(0, Math.min(width, Math.round(filled)));
+  return `[${"\u2588".repeat(cells)}${"\u2591".repeat(width - cells)}] ${counts.reported}/${counts.started} reported`;
 }
 function waitLine(wait) {
   if (wait.type === "permission")
@@ -1727,7 +1727,7 @@ function statusLine(row) {
   return statusParts(row).map((part) => part.text).join(" \xB7 ");
 }
 function statusParts(row) {
-  const parts2 = [{
+  const parts = [{
     text: stateWord(row),
     kind: "state"
   }, {
@@ -1740,7 +1740,7 @@ function statusParts(row) {
     text: row.isolated ? "isolated" : "",
     kind: "plain"
   }];
-  return parts2.filter((part) => part.text);
+  return parts.filter((part) => part.text);
 }
 var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 function rowMark(row, theme, frame) {
@@ -1796,16 +1796,16 @@ function stateWord(row) {
     return row.outcome;
   return row.state;
 }
-function reportWords(report2, stopped) {
-  if (!report2)
+function reportWords(report, stopped) {
+  if (!report)
     return "";
-  if (report2.state === "owed")
+  if (report.state === "owed")
     return "owes a report";
-  if (report2.state === "ended")
+  if (report.state === "ended")
     return stopped ? "" : "ended without a report";
-  return ["reported", report2.status].filter(Boolean).join(" ");
+  return ["reported", report.status].filter(Boolean).join(" ");
 }
-var counted = (count2, noun) => `${count2} ${noun}${count2 === 1 ? "" : "s"}`;
+var counted = (count, noun) => `${count} ${noun}${count === 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);
@@ -1835,7 +1835,7 @@ function courierOf(ctx) {
 var REREAD_MS = 15000;
 function changes(ctx, types, settle) {
   const [changed, setChanged] = createSignal(0);
-  const reread = setInterval(() => setChanged((count2) => count2 + 1), REREAD_MS);
+  const reread = setInterval(() => setChanged((count) => count + 1), REREAD_MS);
   let settling;
   const unlisten = ctx.data.listen(({
     details
@@ -1844,7 +1844,7 @@ function changes(ctx, types, settle) {
       return;
     settling = setTimeout(() => {
       settling = undefined;
-      setChanged((count2) => count2 + 1);
+      setChanged((count) => count + 1);
     }, settle);
   });
   return [changed, () => {
@@ -2487,9 +2487,9 @@ function TreePanel(props) {
             get each() {
               return statusParts(row);
             },
-            children: (part, at2) => [_$createComponent(Show, {
+            children: (part, at) => [_$createComponent(Show, {
               get when() {
-                return at2();
+                return at();
               },
               get children() {
                 var _el$32 = _$createElement("text");
@@ -2527,7 +2527,7 @@ function TreePanel(props) {
                     get each() {
                       return line.split(" \xB7 ");
                     },
-                    children: (part, at2) => [_$memo(() => at2() ? " \xB7 " : ""), _$memo(() => _$memo(() => part === `ctx ${Math.round(row.context * 100)}%`)() ? (() => {
+                    children: (part, at) => [_$memo(() => at() ? " \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", {
@@ -2664,7 +2664,7 @@ function addTreePanel(ctx, verbs = {}) {
     return;
   });
   const follow = (from, sessionID) => {
-    const token2 = ++attempt;
+    const token = ++attempt;
     const under = (tree) => tree?.rows.some((row) => row.sessionID === sessionID) === true;
     Object.assign(from, {
       at: undefined,
@@ -2675,7 +2675,7 @@ function addTreePanel(ctx, verbs = {}) {
     (async () => {
       const inside = await treeOf(from.root);
       const own = under(inside) ? undefined : await treeOf(sessionID);
-      if (token2 !== attempt || following !== from)
+      if (token !== attempt || following !== from)
         return;
       if (under(inside))
         show(from, sessionID, from.root, inside);
@@ -2769,10 +2769,10 @@ function addTreePanel(ctx, verbs = {}) {
       });
     const sessionID = target || await ctx.ui.dialog.select({
       title: "Stop which session?",
-      options: rows.map((row2) => ({
-        title: row2.title,
-        value: row2.sessionID,
-        description: `${row2.sessionID} \xB7 ${statusLine(row2)}`
+      options: rows.map((row) => ({
+        title: row.title,
+        value: row.sessionID,
+        description: `${row.sessionID} \xB7 ${statusLine(row)}`
       }))
     });
     if (!sessionID)