opencode-courier 0.3.0 → 0.4.1

package/dist/tui.js

@@ -0,0 +1,1342 @@
+// @bun
+// src/tui.tsx
+import { Plugin } from "@opencode/plugin/tui";
+
+// src/person/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
+import { Schema } from "effect";
+var Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var Session = Schema.Struct({
+  sessionID: Schema.String,
+  title: Schema.String,
+  parentID: Schema.String,
+  depth: Count,
+  group: Schema.optionalKey(Schema.String)
+});
+var Permission = Schema.Struct({
+  sessionID: Schema.String,
+  requestID: Schema.String,
+  action: Schema.String,
+  resources: Schema.Array(Schema.String),
+  save: Schema.optionalKey(Schema.Array(Schema.String))
+});
+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 Question = Schema.Struct({
+  sessionID: Schema.String,
+  requestID: Schema.String,
+  questions: Schema.Array(Prompt),
+  stopped: Schema.optionalKey(Schema.Boolean)
+});
+var Asks = Schema.Struct({
+  top: Schema.String,
+  sessions: Schema.Array(Session),
+  permissions: Schema.Array(Permission),
+  questions: Schema.Array(Question),
+  truncated: Schema.optionalKey(Count)
+});
+var Answered = Schema.Struct({
+  answered: Schema.Boolean,
+  by: Schema.optionalKey(Schema.Literals(["result", "message"])),
+  problem: Schema.optionalKey(Schema.String)
+});
+var personRpc = Rpc.define({
+  id: "courier-person",
+  methods: {
+    asks: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
+      output: Schema.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)
+    }
+  },
+  events: {}
+});
+
+// src/person/text.ts
+var REJECTED = "Refused by the session that started you. Do without it, or report back why you cannot.";
+
+// src/person/tui.tsx
+var QUESTION_FORM = "question";
+var INBOX_COMMAND = "courier.asks";
+var SETTLE_MS = 250;
+function asksOf(asks, forms) {
+  return asks.sessions.flatMap((session) => [...asks.permissions.filter((request) => request.sessionID === session.sessionID).map((request) => ({
+    kind: "permission",
+    key: `permission ${request.requestID}`,
+    session,
+    request
+  })), ...asks.questions.filter((question) => question.sessionID === session.sessionID).map((question) => ({
+    kind: "question",
+    key: `question ${question.requestID}`,
+    session,
+    question
+  })), ...(forms.get(session.sessionID) ?? []).filter((form) => form.metadata?.kind !== QUESTION_FORM).map((form) => ({
+    kind: "form",
+    key: `form ${form.id}`,
+    session,
+    form
+  }))]);
+}
+function pathOf(asks, sessionID, topTitle) {
+  const byID = new Map(asks.sessions.map((session) => [session.sessionID, session]));
+  const titles = [];
+  for (let at = byID.get(sessionID);at && titles.length <= byID.size; at = byID.get(at.parentID))
+    titles.unshift(at.title);
+  return [topTitle, ...titles].join(" \u203A ");
+}
+var clip = (text, max = 80) => text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+function askTitle(ask) {
+  switch (ask.kind) {
+    case "permission": {
+      const {
+        action,
+        resources
+      } = ask.request;
+      return clip(resources.length ? `Permission: ${action} ${resources.join(", ")}` : `Permission: ${action}`);
+    }
+    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}`);
+    }
+    case "form":
+      return clip(`Form: ${ask.form.title}`);
+  }
+}
+function askFooter(ask) {
+  return [`depth ${ask.session.depth}`, ask.session.group ? `group ${ask.session.group}` : "", ask.kind === "question" && ask.question.stopped ? "cut off, answered by message" : ""].filter(Boolean).join(" \xB7 ");
+}
+var soundOf = (ask) => ask.kind === "permission" ? "permission" : "question";
+function shown(field, answers) {
+  if ("hidden" in field && field.hidden)
+    return false;
+  const when = "when" in field ? field.when ?? [] : [];
+  return when.every((condition) => condition.op === "eq" ? answers[condition.key] === condition.value : answers[condition.key] !== condition.value);
+}
+function chooseOptions(choices, picked, {
+  multiple = false,
+  own = false,
+  optional = false
+}) {
+  const mark = (value) => {
+    if (!multiple)
+      return "";
+    return picked.includes(value) ? "[x] " : "[ ] ";
+  };
+  const theirs = picked.filter((value) => !choices.some((choice) => choice.value === value));
+  return [...choices.map((choice) => ({
+    title: `${mark(choice.value)}${choice.label}`,
+    value: choice.value,
+    ...choice.description ? {
+      description: choice.description
+    } : {}
+  })), ...theirs.map((value) => ({
+    title: `[x] ${value}`,
+    value
+  })), ...own ? [{
+    title: "Type your own answer\u2026",
+    value: OWN
+  }] : [], ...multiple ? [{
+    title: "Done",
+    value: DONE,
+    description: picked.length ? picked.join(", ") : "nothing chosen"
+  }] : [], ...optional && !multiple ? [{
+    title: "Skip",
+    value: SKIP
+  }] : []];
+}
+function toggle(picked, value) {
+  const at = picked.indexOf(value);
+  if (at >= 0)
+    picked.splice(at, 1);
+  else
+    picked.push(value);
+}
+var OWN = Symbol("own");
+var DONE = Symbol("done");
+var SKIP = Symbol("skip");
+function addAsksInbox(ctx) {
+  const person = ctx.client.rpc(personRpc);
+  const location = (sessionID) => ctx.data.session.get(sessionID)?.location ?? ctx.location ?? ctx.data.location.default();
+  const openSession = () => {
+    const route = ctx.ui.router.current();
+    return route.type === "session" ? route.sessionID : undefined;
+  };
+  const firstSeen = new Map;
+  const answered = new Set;
+  let seen = 0;
+  async function read(sessionID) {
+    const asks = await person.asks({
+      sessionID
+    }, {
+      location: location(sessionID)
+    });
+    const forms = new Map(await Promise.all(asks.sessions.map(async (session) => [session.sessionID, await ctx.client.session.form.list({
+      sessionID: session.sessionID
+    }).catch(() => [])])));
+    const listed = asksOf(asks, forms).filter((ask) => !answered.has(ask.key));
+    for (const ask of listed)
+      if (!firstSeen.has(ask.key))
+        firstSeen.set(ask.key, seen++);
+    listed.sort((a, b) => firstSeen.get(a.key) - firstSeen.get(b.key));
+    return {
+      asks,
+      listed
+    };
+  }
+  const fail = (what) => (error) => ctx.ui.toast.show({
+    title: "courier",
+    message: `${what}: ${error instanceof Error ? error.message : String(error)}`,
+    variant: "error"
+  });
+  async function choose(title, choices, {
+    multiple = false,
+    own = false,
+    optional = false
+  } = {}) {
+    const picked = [];
+    for (;; ) {
+      const value = await ctx.ui.dialog.select({
+        title,
+        options: chooseOptions(choices, picked, {
+          multiple,
+          own,
+          optional
+        })
+      });
+      if (value === undefined)
+        return;
+      if (value === DONE)
+        return picked;
+      if (value === SKIP)
+        return [];
+      const chosen = value === OWN ? (await ctx.ui.dialog.prompt({
+        title,
+        placeholder: "Your answer"
+      }))?.trim() : value;
+      if (!chosen)
+        continue;
+      if (!multiple)
+        return [chosen];
+      toggle(picked, chosen);
+    }
+  }
+  async function answerPermission(ask) {
+    const {
+      request
+    } = ask;
+    const decision = await ctx.ui.dialog.select({
+      title: askTitle(ask),
+      options: [{
+        title: "Allow once",
+        value: "once"
+      }, ...request.save?.length ? [{
+        title: "Always allow",
+        value: "always",
+        description: request.save.join(", ")
+      }] : [], {
+        title: "Reject",
+        value: "reject",
+        description: "the session's call fails and it carries on"
+      }, {
+        title: "Reject with a reason\u2026",
+        value: "reason"
+      }]
+    });
+    if (decision === undefined)
+      return false;
+    const message = decision === "reason" ? await ctx.ui.dialog.prompt({
+      title: "Why not?",
+      placeholder: "Passed on to the session"
+    }) : undefined;
+    if (decision === "reason" && message === undefined)
+      return false;
+    const reply = decision === "reason" ? "reject" : decision;
+    await ctx.client.permission.reply({
+      sessionID: request.sessionID,
+      requestID: request.requestID,
+      decision: reply,
+      ...reply === "reject" ? {
+        message: message?.trim() || REJECTED
+      } : {}
+    });
+    return true;
+  }
+  async function answerQuestion(ask) {
+    const {
+      question
+    } = ask;
+    const answers = [];
+    for (const [index, prompt] of question.questions.entries()) {
+      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}${count}`, choices, {
+        multiple: !!prompt.multiple,
+        own: true
+      });
+      if (picked === undefined)
+        return false;
+      answers.push(picked);
+    }
+    const result = await person.answer({
+      sessionID: question.sessionID,
+      requestID: question.requestID,
+      answers
+    }, {
+      location: location(question.sessionID)
+    });
+    if (result.problem)
+      throw new Error(result.problem);
+    if (!result.answered)
+      ctx.ui.toast.show({
+        title: "courier",
+        message: "It no longer waits: answered or settled some other way.",
+        variant: "warning"
+      });
+    return true;
+  }
+  async function typed(title, field, optional) {
+    for (;; ) {
+      const text = await ctx.ui.dialog.prompt({
+        title,
+        ...field.description ? {
+          description: field.description
+        } : {},
+        ...field.default ? {
+          value: field.default
+        } : {}
+      });
+      if (text === undefined)
+        return;
+      if (text || optional)
+        return text || SKIP;
+    }
+  }
+  async function numeric(title, field, optional) {
+    const whole = field.type === "integer";
+    for (;; ) {
+      const text = await typed(title, {
+        ...field.description ? {
+          description: field.description
+        } : {}
+      }, optional);
+      if (text === undefined || text === SKIP)
+        return text;
+      const value = Number(text);
+      if (Number.isFinite(value) && (!whole || Number.isInteger(value)))
+        return value;
+      ctx.ui.toast.show({
+        title: "courier",
+        message: `${title} takes ${whole ? "a whole number" : "a number"}`,
+        variant: "warning"
+      });
+    }
+  }
+  async function answerField(field) {
+    const title = field.title ?? field.key;
+    const optional = !(("required" in field) && field.required);
+    switch (field.type) {
+      case "external":
+        await ctx.ui.dialog.alert({
+          title,
+          message: `This form opens ${field.url}: answer it in its own session.`
+        });
+        return;
+      case "boolean":
+        return ctx.ui.dialog.select({
+          title,
+          options: [{
+            title: "Yes",
+            value: true
+          }, {
+            title: "No",
+            value: false
+          }]
+        });
+      case "multiselect": {
+        const picked = await choose(title, field.options, {
+          multiple: true,
+          own: !!field.custom
+        });
+        if (picked?.length === 0 && optional)
+          return SKIP;
+        return picked;
+      }
+      case "string": {
+        if (!field.options?.length)
+          return typed(title, field, optional);
+        const picked = await choose(title, field.options, {
+          own: !!field.custom,
+          optional
+        });
+        return picked && (picked[0] ?? SKIP);
+      }
+      case "number":
+      case "integer":
+        return numeric(title, field, optional);
+    }
+  }
+  async function answerForm(ask) {
+    const {
+      form
+    } = ask;
+    const answer2 = {};
+    for (const field of form.fields) {
+      if (!shown(field, answer2))
+        continue;
+      const value = await answerField(field);
+      if (value === undefined)
+        return false;
+      if (value !== SKIP)
+        answer2[field.key] = value;
+    }
+    await ctx.data.session.form.reply({
+      sessionID: form.sessionID,
+      formID: form.id,
+      answer: answer2
+    });
+    return true;
+  }
+  const answer = (ask) => {
+    switch (ask.kind) {
+      case "permission":
+        return answerPermission(ask);
+      case "question":
+        return answerQuestion(ask);
+      case "form":
+        return answerForm(ask);
+    }
+  };
+  let opened = false;
+  async function open(sessionID = openSession()) {
+    if (!sessionID) {
+      ctx.ui.toast.show({
+        title: "courier",
+        message: "Open a session to see what its sessions ask you.",
+        variant: "info"
+      });
+      return;
+    }
+    if (opened)
+      return;
+    opened = true;
+    try {
+      for (let first = true;; first = false) {
+        const found = await read(sessionID).catch(fail("The asks could not be read"));
+        if (!found)
+          return;
+        const {
+          asks,
+          listed
+        } = found;
+        if (!listed.length) {
+          if (first)
+            ctx.ui.toast.show({
+              title: "courier",
+              message: "Nothing in this courier tree waits on you.",
+              variant: "info"
+            });
+          return;
+        }
+        const top = ctx.data.session.get(asks.top)?.title ?? asks.top;
+        const choosing = ctx.ui.dialog.select({
+          title: `Waiting on you (${listed.length})`,
+          placeholder: "Search",
+          options: listed.map((ask) => ({
+            title: askTitle(ask),
+            value: ask,
+            description: pathOf(asks, ask.session.sessionID, top),
+            footer: askFooter(ask)
+          }))
+        });
+        ctx.ui.dialog.set({
+          size: "large"
+        });
+        const chosen = await choosing;
+        if (!chosen)
+          return;
+        const done = await answer(chosen).catch((error) => {
+          fail("The answer was not passed on")(error);
+          return false;
+        });
+        if (done)
+          answered.add(chosen.key);
+      }
+    } finally {
+      opened = false;
+    }
+  }
+  const sounded = new Set;
+  let settling;
+  const sound = async () => {
+    const sessionID = openSession();
+    if (!sessionID)
+      return;
+    const {
+      asks,
+      listed
+    } = await read(sessionID);
+    const top = ctx.data.session.get(asks.top)?.title ?? asks.top;
+    for (const ask of listed) {
+      if (sounded.has(ask.key))
+        continue;
+      sounded.add(ask.key);
+      ctx.attention.notify({
+        title: pathOf(asks, ask.session.sessionID, top),
+        message: askTitle(ask),
+        notification: {
+          when: "blurred"
+        },
+        sound: {
+          name: soundOf(ask),
+          when: "always"
+        }
+      });
+    }
+  };
+  const unlisten = ctx.data.listen(({
+    details
+  }) => {
+    if (details.type !== "permission.asked" && details.type !== "form.created" || settling)
+      return;
+    settling = setTimeout(() => {
+      settling = undefined;
+      sound().catch(() => {
+        return;
+      });
+    }, SETTLE_MS);
+  });
+  ctx.keymap.layer(() => ({
+    mode: "global",
+    commands: [{
+      id: INBOX_COMMAND,
+      title: "Courier: what waits on you",
+      description: "Answer the permission requests, questions and forms of the sessions started with courier",
+      group: "Courier",
+      bind: "<leader>k",
+      palette: true,
+      slash: {
+        name: "asks",
+        aliases: ["ask"]
+      },
+      run: () => void open()
+    }]
+  }));
+  return {
+    open,
+    cleanup: () => {
+      clearTimeout(settling);
+      unlisten();
+    }
+  };
+}
+
+// src/tree/tui.tsx
+import { use as _$use } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+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, createResource, createRoot, createSignal, For, onCleanup, onMount, Show, untrack } from "solid-js";
+
+// 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,
+  groups: Schema2.Array(Group),
+  truncated: Schema2.optionalKey(Count2)
+});
+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 })
+]);
+var Row = Schema2.Struct({
+  sessionID: Schema2.String,
+  parentID: Schema2.String,
+  title: Schema2.String,
+  depth: Count2,
+  state: Schema2.Literals(["running", "waiting", "idle", "gone"]),
+  outcome: Schema2.optionalKey(Schema2.Literals(["succeeded", "failed", "interrupted"])),
+  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 Tree = Schema2.Struct({
+  rows: Schema2.Array(Row),
+  truncated: Schema2.optionalKey(Count2)
+});
+var Stopped = Schema2.Struct({
+  stopped: Schema2.Array(Schema2.Struct({ sessionID: Schema2.String, title: Schema2.String, outcome: Schema2.String })),
+  cancelled: Count2
+});
+var treeRpc = Rpc2.define({
+  id: "courier",
+  methods: {
+    summary: {
+      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String })),
+      output: Schema2.toStandardSchemaV1(Summary)
+    },
+    tree: {
+      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String })),
+      output: Schema2.toStandardSchemaV1(Tree)
+    },
+    stop: {
+      input: Schema2.toStandardSchemaV1(Schema2.Struct({ sessionID: Schema2.String, by: Schema2.String })),
+      output: Schema2.toStandardSchemaV1(Stopped),
+      errors: { refused: Schema2.toStandardSchemaV1(Schema2.Struct({})) }
+    }
+  },
+  events: {}
+});
+
+// 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 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;
+var PANEL = "courier-tree";
+var TICK_MS = 1000;
+function summaryLine(summary) {
+  const parts = [summary.running ? `${summary.running} running` : "", summary.waiting ? `${summary.waiting} waiting on you` : "", summary.idle ? `${summary.idle} idle` : "", ...summary.groups.map((group) => `group ${group.name} ${group.reported}/${group.members}`), summary.truncated ? `first ${summary.truncated} counted` : ""].filter(Boolean);
+  return parts.length ? `courier ${parts.join(" \xB7 ")}` : "";
+}
+function duration(ms) {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  const pad = (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`;
+}
+function parts(rows, parentID) {
+  const children = rows.filter((row) => row.parentID === parentID);
+  return {
+    reported: children.filter((row) => row.report?.state === "reported").length,
+    started: children.length
+  };
+}
+function bar({
+  reported,
+  started
+}, width = 10) {
+  const filled = started ? Math.round(reported / started * width) : 0;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}] ${reported}/${started} reported`;
+}
+function waitLine(wait) {
+  return wait.type === "permission" ? `asks permission: ${[wait.action, ...wait.resources].join(" ")}` : `asks: ${wait.question}`;
+}
+function statusLine(row) {
+  return [stateWord(row), reportWords(row.report), row.group ? `group ${row.group.name} ${row.group.standing}` : "", row.isolated ? "isolated" : ""].filter(Boolean).join(" \xB7 ");
+}
+function stateWord(row) {
+  if (row.state === "waiting")
+    return "waiting on you";
+  if (row.state === "idle" && (row.outcome === "failed" || row.outcome === "interrupted"))
+    return row.outcome;
+  return row.state;
+}
+function reportWords(report) {
+  if (!report)
+    return "";
+  if (report.state === "owed")
+    return "owes a report";
+  if (report.state === "ended")
+    return "ended without a report";
+  return ["reported", report.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 ");
+}
+function detailLines(row, rows, now) {
+  const started = parts(rows, row.sessionID);
+  if (row.waits.length)
+    return [...started.started ? [bar(started)] : [], ...row.waits.map(waitLine)];
+  if (started.started)
+    return [bar(started)];
+  return row.state === "gone" ? [] : [activityLine(row, now)];
+}
+function courierOf(ctx) {
+  const courier = ctx.client.rpc(treeRpc);
+  const location = (sessionID) => ctx.data.session.get(sessionID)?.location ?? ctx.location ?? ctx.data.location.default();
+  return {
+    courier,
+    location
+  };
+}
+function changes(ctx, types, settle) {
+  const [changed, setChanged] = createSignal(0);
+  let settling;
+  const unlisten = ctx.data.listen(({
+    details
+  }) => {
+    if (!types.has(details.type) || settling)
+      return;
+    settling = setTimeout(() => {
+      settling = undefined;
+      setChanged((count) => count + 1);
+    }, settle);
+  });
+  return [changed, () => {
+    clearTimeout(settling);
+    unlisten();
+  }];
+}
+function reason(error) {
+  if (error instanceof Error)
+    return error.message;
+  return typeof error === "object" && error && "message" in error ? String(error.message) : String(error);
+}
+function addTreeStatus(ctx, onWaiting) {
+  const {
+    courier,
+    location
+  } = courierOf(ctx);
+  const [changed, stopListening] = changes(ctx, CHANGES, SETTLE_MS2);
+  const release = ctx.ui.slot({
+    append: "prompt.footer.status",
+    render: (input) => {
+      const [read] = createResource(() => input.sessionID ? {
+        sessionID: input.sessionID,
+        changed: changed()
+      } : undefined, ({
+        sessionID
+      }) => courier.summary({
+        sessionID
+      }, {
+        location: location(sessionID)
+      }).then((summary) => ({
+        sessionID,
+        line: summaryLine(summary),
+        waiting: summary.waiting
+      }), () => ({
+        sessionID,
+        line: "",
+        waiting: 0
+      })));
+      const shown2 = () => {
+        const latest = read.state === "ready" || read.state === "refreshing" ? read.latest : undefined;
+        return latest && latest.sessionID === input.sessionID ? latest : undefined;
+      };
+      const line = () => shown2()?.line ?? "";
+      const click = () => {
+        const latest = shown2();
+        if (latest?.waiting)
+          onWaiting?.(latest.sessionID);
+      };
+      return _$createComponent(Show, {
+        get when() {
+          return line();
+        },
+        get children() {
+          var _el$ = _$createElement("text"), _el$2 = _$createTextNode(` `);
+          _$insertNode(_el$, _el$2);
+          _$setProp(_el$, "wrapMode", "none");
+          _$setProp(_el$, "onMouseUp", click);
+          _$insert(_el$, line, null);
+          _$effect((_$p) => _$setProp(_el$, "fg", ctx.theme.text.muted, _$p));
+          return _el$;
+        }
+      });
+    }
+  });
+  return () => {
+    stopListening();
+    release();
+  };
+}
+function reach(rows, sessionID) {
+  return 1 + rows.filter((row) => row.parentID === sessionID).reduce((total, row) => total + reach(rows, row.sessionID), 0);
+}
+function stoppedLine({
+  stopped,
+  cancelled
+}) {
+  const interrupted = stopped.filter((one) => one.outcome === "interrupted").length;
+  const failed = stopped.filter((one) => one.outcome === "failed").length;
+  return [`Stopped ${counted(stopped.length, "session")}: ${interrupted} interrupted`, failed ? `${failed} failed to stop` : "", cancelled ? `${counted(cancelled, "scheduled message")} cancelled` : ""].filter(Boolean).join(", ");
+}
+async function confirmStop(ctx, courier, location, by, target) {
+  const under = target.under ? ` and the ${counted(target.under, "session")} under it` : "";
+  const confirmed = await ctx.ui.dialog.confirm({
+    title: "Stop session",
+    message: `Stop "${target.title}" (${target.sessionID})${under}? Their turns are interrupted and their scheduled messages cancelled, as courier_stop does.`,
+    label: {
+      confirm: "Stop",
+      cancel: "Keep running"
+    }
+  });
+  if (!confirmed)
+    return false;
+  try {
+    const result = await courier.stop({
+      sessionID: target.sessionID,
+      by
+    }, {
+      location: location(by)
+    });
+    ctx.ui.toast.show({
+      title: "courier",
+      message: stoppedLine(result),
+      variant: "success"
+    });
+  } catch (error) {
+    ctx.ui.toast.show({
+      title: "courier stop",
+      message: reason(error),
+      variant: "error"
+    });
+  }
+  return true;
+}
+var FOCUS_PROMPT = "pane.focus.left";
+function TreePanel(props) {
+  const {
+    ctx,
+    input,
+    view,
+    courier,
+    location
+  } = props;
+  const theme = ctx.theme;
+  const [read, {
+    refetch
+  }] = createResource(() => ({
+    sessionID: view.root,
+    changed: props.changed()
+  }), ({
+    sessionID
+  }) => courier.tree({
+    sessionID
+  }, {
+    location: location(sessionID)
+  }).then((tree) => ({
+    sessionID,
+    tree
+  }), (error) => ({
+    sessionID,
+    error: reason(error)
+  })));
+  const latest = () => read.state === "ready" || read.state === "refreshing" ? read.latest : view.tree && {
+    sessionID: view.root,
+    tree: view.tree
+  };
+  const rows = () => latest()?.tree?.rows ?? [];
+  createEffect(() => {
+    const tree = latest()?.tree;
+    if (tree)
+      view.note({
+        tree
+      });
+  });
+  createEffect(() => view.note({
+    presentation: input.presentation,
+    focused: input.focused
+  }));
+  onMount(() => {
+    if (!view.refocus)
+      return;
+    const giveBack = setTimeout(() => ctx.keymap.dispatch(FOCUS_PROMPT));
+    onCleanup(() => clearTimeout(giveBack));
+  });
+  const [now, setNow] = createSignal(Date.now());
+  const tick = setInterval(() => setNow(Date.now()), TICK_MS);
+  onCleanup(() => clearInterval(tick));
+  const [selected, setSelected] = createSignal(0);
+  let placed = false;
+  createEffect(() => {
+    const index = placed ? -1 : rows().findIndex((row) => row.sessionID === input.sessionID);
+    if (index < 0)
+      return;
+    placed = true;
+    setSelected(index);
+  });
+  const current = () => rows()[Math.min(selected(), rows().length - 1)];
+  let scroll;
+  createEffect(() => {
+    const index = Math.min(selected(), rows().length - 1);
+    if (index >= 0)
+      scroll?.scrollChildIntoView(`courier-row-${index}`);
+  });
+  const move = (by) => setSelected((index) => Math.max(0, Math.min(rows().length - 1, Math.min(index, rows().length - 1) + by)));
+  const open = () => {
+    const row = current();
+    if (row)
+      ctx.ui.router.navigate({
+        type: "session",
+        sessionID: row.sessionID
+      });
+  };
+  const stopSelected = () => {
+    const row = current();
+    if (row)
+      confirmStop(ctx, courier, location, view.root, {
+        sessionID: row.sessionID,
+        title: row.title,
+        under: reach(rows(), row.sessionID) - 1
+      });
+  };
+  ctx.keymap.layer(() => ({
+    priority: 10,
+    enabled: () => input.focused,
+    commands: [{
+      bind: "up",
+      title: "Previous session",
+      group: "Courier",
+      run: () => move(-1)
+    }, {
+      bind: "k",
+      title: "Previous session",
+      group: "Courier",
+      run: () => move(-1)
+    }, {
+      bind: "down",
+      title: "Next session",
+      group: "Courier",
+      run: () => move(1)
+    }, {
+      bind: "j",
+      title: "Next session",
+      group: "Courier",
+      run: () => move(1)
+    }, {
+      bind: "return",
+      title: "Open session",
+      group: "Courier",
+      run: open
+    }, {
+      bind: "s",
+      title: "Stop session and those under it",
+      group: "Courier",
+      run: stopSelected
+    }, {
+      bind: "r",
+      title: "Refresh",
+      group: "Courier",
+      run: () => void refetch()
+    }, {
+      bind: "f",
+      title: "Toggle fullscreen",
+      group: "Courier",
+      run: () => input.toggleFullscreen()
+    }, {
+      bind: "q",
+      title: "Close courier tree",
+      group: "Courier",
+      run: () => input.close()
+    }]
+  }));
+  const root = () => parts(rows(), view.root);
+  const rowColor = (row) => {
+    if (row.state === "waiting")
+      return theme.text.feedback.warning.base;
+    return row.state === "gone" ? theme.text.muted : theme.text.base;
+  };
+  return (() => {
+    var _el$3 = _$createElement("box"), _el$4 = _$createElement("box"), _el$5 = _$createElement("text"), _el$13 = _$createElement("scrollbox"), _el$14 = _$createElement("text");
+    _$insertNode(_el$3, _el$4);
+    _$insertNode(_el$3, _el$13);
+    _$insertNode(_el$3, _el$14);
+    _$setProp(_el$3, "flexDirection", "column");
+    _$setProp(_el$3, "flexGrow", 1);
+    _$setProp(_el$3, "paddingLeft", 1);
+    _$setProp(_el$3, "paddingRight", 1);
+    _$insertNode(_el$4, _el$5);
+    _$setProp(_el$4, "flexDirection", "row");
+    _$setProp(_el$4, "flexShrink", 0);
+    _$setProp(_el$4, "gap", 2);
+    _$insertNode(_el$5, _$createTextNode(`courier tree`));
+    _$setProp(_el$5, "wrapMode", "none");
+    _$insert(_el$4, _$createComponent(Show, {
+      get when() {
+        return root().started;
+      },
+      get children() {
+        var _el$7 = _$createElement("text");
+        _$setProp(_el$7, "wrapMode", "none");
+        _$insert(_el$7, () => bar(root()));
+        _$effect((_$p) => _$setProp(_el$7, "fg", theme.text.muted, _$p));
+        return _el$7;
+      }
+    }), null);
+    _$insert(_el$4, _$createComponent(Show, {
+      get when() {
+        return latest()?.tree?.truncated;
+      },
+      get children() {
+        var _el$8 = _$createElement("text"), _el$9 = _$createTextNode(`first `), _el$0 = _$createTextNode(` shown`);
+        _$insertNode(_el$8, _el$9);
+        _$insertNode(_el$8, _el$0);
+        _$setProp(_el$8, "wrapMode", "none");
+        _$insert(_el$8, () => latest()?.tree?.truncated, _el$0);
+        _$effect((_$p) => _$setProp(_el$8, "fg", theme.text.feedback.warning.base, _$p));
+        return _el$8;
+      }
+    }), null);
+    _$insert(_el$3, _$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;
+      }
+    }), _el$13);
+    _$insert(_el$3, _$createComponent(Show, {
+      get when() {
+        return _$memo(() => !!latest()?.tree)() && !rows().length;
+      },
+      get children() {
+        var _el$11 = _$createElement("text");
+        _$insertNode(_el$11, _$createTextNode(`No session started with courier_spawn under this one.`));
+        _$effect((_$p) => _$setProp(_el$11, "fg", theme.text.muted, _$p));
+        return _el$11;
+      }
+    }), _el$13);
+    _$use((value) => scroll = value, _el$13);
+    _$setProp(_el$13, "flexGrow", 1);
+    _$insert(_el$13, _$createComponent(For, {
+      get each() {
+        return rows();
+      },
+      children: (row, index) => {
+        const chosen = () => index() === Math.min(selected(), rows().length - 1);
+        const indent = "  ".repeat(row.depth - 1);
+        return (() => {
+          var _el$16 = _$createElement("box"), _el$17 = _$createElement("text"), _el$18 = _$createTextNode(`  `), _el$19 = _$createElement("span");
+          _$insertNode(_el$16, _el$17);
+          _$setProp(_el$16, "flexDirection", "column");
+          _$setProp(_el$16, "flexShrink", 0);
+          _$insertNode(_el$17, _el$18);
+          _$insertNode(_el$17, _el$19);
+          _$setProp(_el$17, "wrapMode", "none");
+          _$insert(_el$17, indent, _el$18);
+          _$insert(_el$17, () => chosen() ? "\u25B8 " : "  ", _el$18);
+          _$insert(_el$17, () => row.title, _el$18);
+          _$insert(_el$17, () => row.sessionID === input.sessionID ? " (on screen)" : "", _el$18);
+          _$insert(_el$19, () => statusLine(row));
+          _$insert(_el$16, _$createComponent(For, {
+            get each() {
+              return detailLines(row, rows(), now());
+            },
+            children: (line) => (() => {
+              var _el$20 = _$createElement("text"), _el$21 = _$createTextNode(`    `);
+              _$insertNode(_el$20, _el$21);
+              _$setProp(_el$20, "wrapMode", "none");
+              _$insert(_el$20, indent, _el$21);
+              _$insert(_el$20, line, null);
+              _$effect((_$p) => _$setProp(_el$20, "fg", theme.text.muted, _$p));
+              return _el$20;
+            })()
+          }), 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 = {
+              fg: theme.text.muted
+            };
+            _v$3 !== _p$.e && (_p$.e = _$setProp(_el$16, "id", _v$3, _p$.e));
+            _v$4 !== _p$.t && (_p$.t = _$setProp(_el$16, "backgroundColor", _v$4, _p$.t));
+            _v$5 !== _p$.a && (_p$.a = _$setProp(_el$17, "fg", _v$5, _p$.a));
+            _v$6 !== _p$.o && (_p$.o = _$setProp(_el$19, "style", _v$6, _p$.o));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined,
+            a: undefined,
+            o: undefined
+          });
+          return _el$16;
+        })();
+      }
+    }));
+    _$insertNode(_el$14, _$createTextNode(`\u2191\u2193 select \xB7 enter open \xB7 s stop \xB7 r refresh \xB7 f fullscreen \xB7 q close`));
+    _$setProp(_el$14, "wrapMode", "none");
+    _$setProp(_el$14, "flexShrink", 0);
+    _$effect((_p$) => {
+      var _v$ = theme.text.base, _v$2 = theme.text.muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$5, "fg", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$14, "fg", _v$2, _p$.t));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined
+    });
+    return _el$3;
+  })();
+}
+var USAGE = "/courier tree opens the session tree; /courier stop [session] stops a session and those under it";
+function addTreePanel(ctx) {
+  const {
+    courier,
+    location
+  } = courierOf(ctx);
+  const [changed, stopListening] = changes(ctx, PANEL_CHANGES, PANEL_SETTLE_MS);
+  let following;
+  let attempt = 0;
+  const viewOf = (sessionID) => {
+    const here = following?.at === sessionID ? following : undefined;
+    const refocus = here?.refocus === true;
+    if (here)
+      here.refocus = false;
+    return {
+      root: here?.root ?? sessionID,
+      tree: here?.tree,
+      refocus,
+      note: (fields) => {
+        if (here && following === here)
+          Object.assign(here, fields);
+      }
+    };
+  };
+  const release = ctx.ui.slot({
+    append: "session.panel",
+    render: (input) => _$createComponent(Show, {
+      get when() {
+        return input.name === PANEL;
+      },
+      get children() {
+        return _$createComponent(TreePanel, {
+          ctx,
+          input,
+          get view() {
+            return viewOf(input.sessionID);
+          },
+          courier,
+          location,
+          changed
+        });
+      }
+    })
+  });
+  const show = (from, at, root, tree) => {
+    following = {
+      ...from,
+      root,
+      at,
+      to: undefined,
+      tree,
+      refocus: !from.focused
+    };
+    ctx.ui.panel.open(PANEL, {
+      presentation: from.presentation
+    });
+  };
+  const treeOf = (sessionID) => courier.tree({
+    sessionID
+  }, {
+    location: location(sessionID)
+  }).catch(() => {
+    return;
+  });
+  const follow = (from, sessionID) => {
+    const token = ++attempt;
+    const under = (tree) => tree?.rows.some((row) => row.sessionID === sessionID) === true;
+    Object.assign(from, {
+      at: undefined,
+      to: sessionID
+    });
+    if (sessionID === from.root || under(from.tree))
+      return show(from, sessionID, from.root, from.tree);
+    (async () => {
+      const inside = await treeOf(from.root);
+      const own = under(inside) ? undefined : await treeOf(sessionID);
+      if (token !== attempt || following !== from)
+        return;
+      if (under(inside))
+        show(from, sessionID, from.root, inside);
+      else if (own?.rows.length)
+        show(from, sessionID, sessionID, own);
+      else
+        following = undefined;
+    })();
+  };
+  const stopFollowing = createRoot((dispose) => {
+    createEffect(() => {
+      const route = ctx.ui.router.current();
+      const sessionID = route.type === "session" ? route.sessionID : undefined;
+      const shown2 = ctx.ui.panel.current();
+      untrack(() => {
+        if (!following || shown2 && shown2.sessionID === sessionID || !following.at && following.to === sessionID)
+          return;
+        if (!shown2 && following.at === sessionID || !sessionID)
+          following = undefined;
+        else
+          follow(following, sessionID);
+      });
+    });
+    return dispose;
+  });
+  const openPanel = () => {
+    const route = ctx.ui.router.current();
+    const before = following;
+    if (route.type === "session" && following?.at !== route.sessionID)
+      following = {
+        root: route.sessionID,
+        at: route.sessionID,
+        presentation: "panel",
+        focused: true
+      };
+    if (ctx.ui.panel.open(PANEL))
+      return;
+    following = before;
+    ctx.ui.toast.show({
+      title: "courier",
+      message: "Open a session first",
+      variant: "warning"
+    });
+  };
+  const stopUnder = async (target) => {
+    const route = ctx.ui.router.current();
+    if (route.type !== "session")
+      return ctx.ui.toast.show({
+        title: "courier",
+        message: "Open a session first",
+        variant: "warning"
+      });
+    const rows = await courier.tree({
+      sessionID: route.sessionID
+    }, {
+      location: location(route.sessionID)
+    }).then((tree) => tree.rows, () => []);
+    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)}`
+      }))
+    });
+    if (!sessionID)
+      return;
+    const row = rows.find((one) => one.sessionID === sessionID);
+    await confirmStop(ctx, courier, location, route.sessionID, {
+      sessionID,
+      title: row?.title ?? sessionID,
+      under: row ? reach(rows, sessionID) - 1 : 0
+    });
+  };
+  ctx.keymap.layer(() => ({
+    mode: "global",
+    commands: [{
+      id: "courier.command",
+      title: "Courier",
+      description: USAGE,
+      group: "Courier",
+      slash: {
+        name: "courier",
+        arguments: true
+      },
+      run: async (input) => {
+        const [verb = "tree", target = ""] = (input ?? "").trim().split(/\s+/).filter(Boolean);
+        if (verb === "tree")
+          return openPanel();
+        if (verb === "stop")
+          return stopUnder(target);
+        ctx.ui.toast.show({
+          title: "courier",
+          message: USAGE,
+          variant: "warning"
+        });
+      }
+    }, {
+      id: "courier.tree",
+      title: "Courier session tree",
+      group: "Courier",
+      palette: true,
+      run: openPanel
+    }]
+  }));
+  return () => {
+    stopFollowing();
+    stopListening();
+    release();
+  };
+}
+var NOTIFIED_MAX = 500;
+function addTreeAttention(ctx) {
+  const notified = new Set;
+  const title = (sessionID) => ctx.data.session.get(sessionID)?.title;
+  return ctx.data.on("session.inbox.enqueued", (event) => {
+    const {
+      sessionID,
+      inboxID,
+      item
+    } = event.data;
+    const metadata = item.type === "synthetic" ? item.payload.metadata ?? {} : {};
+    if (metadata.source !== "courier" || notified.has(inboxID))
+      return;
+    const group = typeof metadata.group === "string" ? metadata.group : undefined;
+    const status = typeof metadata.status === "string" ? metadata.status : undefined;
+    const from = typeof metadata.from === "string" ? metadata.from : "";
+    if (!group && !status)
+      return;
+    notified.add(inboxID);
+    if (notified.size > NOTIFIED_MAX)
+      notified.delete(notified.values().next().value);
+    (group ? ctx.attention.notify({
+      title: title(sessionID),
+      message: `Group ${group}: ${typeof metadata.reports === "number" ? counted(metadata.reports, "report") : "its reports"} arrived`,
+      notification: {
+        when: "blurred"
+      },
+      sound: {
+        name: "done",
+        when: "always"
+      }
+    }) : ctx.attention.notify({
+      title: title(sessionID),
+      message: `${title(from) ?? from} reported ${status}`,
+      notification: false,
+      sound: {
+        name: "subagent_done",
+        when: "always"
+      }
+    })).catch(() => {
+      return;
+    });
+  });
+}
+
+// src/tui.tsx
+var tui_default = Plugin.define({
+  id: "courier.tui",
+  setup: (ctx) => {
+    const inbox = addAsksInbox(ctx);
+    const cleanups = [inbox.cleanup, addTreeStatus(ctx, (sessionID) => void inbox.open(sessionID)), addTreePanel(ctx), addTreeAttention(ctx)];
+    return () => {
+      for (const cleanup of cleanups.toReversed())
+        cleanup();
+    };
+  }
+});
+export {
+  tui_default as default
+};