opencode-courier 0.7.3 → 0.9.0

package/dist/tui.js

@@ -2,58 +2,536 @@
 // 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", "gone", "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),
+  reads: Schema.optionalKey(Schema.Struct({ shown: Count, read: Count, at: Schema.Number })),
+  pinned: Schema.optionalKey(Schema.Struct({ at: Schema.Number })),
+  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 Pinned = Schema.Struct({ outcome: Schema.Literals(["pinned", "unpinned", "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)
+    },
+    pin: {
+      input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, pinned: Schema.Boolean })),
+      output: Schema.toStandardSchemaV1(Pinned)
+    }
+  },
+  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", "gone", "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, pin 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 PINNED = "Pinned";
+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 times = (n) => n === 1 ? "once" : `${n} times`;
+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()) {
+  if (record.pinned)
+    return PINNED;
+  const moved = localDay(record.movedAt);
+  return moved === localDay(now) ? TODAY : moved;
+}
+function readsLine(reads) {
+  return [reads.shown ? `shown ${times(reads.shown)}` : "", reads.read ? `opened ${times(reads.read)}` : ""].filter(Boolean).join(", ");
+}
+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", record.reads ? readsLine(record.reads) : ""].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 reads = record.reads ? fact("reads", `${readsLine(record.reads).replace(/^./, (first) => first.toUpperCase())}`, `by other trees' courier_recall, last ${minute(record.reads.at)}`) : fact("reads", "Never shown", "no other tree's courier_recall has listed it yet");
+  const pinned = record.pinned ? fact("pinned", "Pinned", `since ${minute(record.pinned.at)}: listed first, never swept; p unpins`) : fact("pinned", "Not pinned", "p pins it: listed first, never swept");
+  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, reads, pinned, ...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 pinnedLine(record, outcome) {
+  const name = `"${nameOf(record)}"`;
+  if (outcome === "pinned")
+    return `Pinned ${name}: listed first, never swept`;
+  if (outcome === "unpinned")
+    return `Unpinned ${name}: kept as the others are`;
+  return `Nothing to pin 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, pin) {
+    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))
+      }, {
+        bind: "p",
+        title: pin.title,
+        onTrigger: (value) => request(pin.ask(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
+    }), {
+      title: "pin",
+      ask: (record) => ({
+        kind: "pin",
+        record
+      })
+    });
+  };
+  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
+  }), {
+    title: record.pinned ? "unpin" : "pin",
+    ask: (line) => ({
+      kind: "pin",
+      record,
+      line
+    })
+  });
+  async function togglePin(record) {
+    const pinned = !record.pinned;
+    try {
+      const result = await memory.pin({
+        sessionID: record.sessionID,
+        pinned
+      }, {
+        location: where()
+      });
+      ctx.ui.toast.show({
+        title: "courier",
+        message: pinnedLine(record, result.outcome),
+        variant: result.outcome === "none" ? "warning" : "success"
+      });
+    } catch (error) {
+      fail(pinned ? "Not pinned" : "Not unpinned")(error);
+    }
+  }
+  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;
+        }
+        if (request.kind === "pin") {
+          await togglePin(request.record);
+          near = [request.record.sessionID];
+          line = request.line;
+          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, pinned first, then newest first under the day each last moved: enter for one in full, p to pin or unpin one, 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 Answered = Schema.Struct({
-  answered: Schema.Boolean,
-  by: Schema.optionalKey(Schema.Literals(["result", "message"])),
-  problem: Schema.optionalKey(Schema.String)
+var Question = Schema2.Struct({
+  sessionID: Schema2.String,
+  requestID: Schema2.String,
+  questions: Schema2.Array(Prompt),
+  stopped: Schema2.optionalKey(Schema2.Boolean)
+});
+var Asks = Schema2.Struct({
+  top: Schema2.String,
+  sessions: Schema2.Array(Session),
+  permissions: Schema2.Array(Permission),
+  questions: Schema2.Array(Question)
+});
+var Answered = Schema2.Struct({
+  answered: Schema2.Boolean,
+  by: Schema2.optionalKey(Schema2.Literals(["result", "message"])),
+  problem: Schema2.optionalKey(Schema2.String)
 });
-var personRpc = Rpc.define({
+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 +581,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 +592,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 +862,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
       });
@@ -882,7 +1360,7 @@ function digby(rise, { top = 6, eyes = "open", slump = false, shift = 0, mound =
     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(10, top, mound, (column) => column + shift >= 6 && column + shift <= 9, shift);
   span(11, 10, mound, undefined, shift);
   span(12, 12, mound, undefined, shift);
   for (const row of [13, 14, 15])
@@ -947,74 +1425,74 @@ function art(state, 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),
-  context: 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: {}
@@ -1053,14 +1531,14 @@ function createMotion(enabled) {
       const now = untrack(moving);
       for (const one of now)
         one.step(FRAME_MS * every);
-      setFrame((count) => count + 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, duration, ease) => {
+  const tween = (from, to, duration2, ease) => {
     if (!enabled || from === to)
       return {
         value: () => to,
@@ -1070,11 +1548,11 @@ function createMotion(enabled) {
       value: from
     };
     const timeline = new Timeline({
-      duration,
+      duration: duration2,
       autoplay: false
     });
     timeline.add(target, {
-      duration,
+      duration: duration2,
       ease,
       value: to
     });
@@ -1087,7 +1565,7 @@ function createMotion(enabled) {
       },
       done: () => {
         frame();
-        return elapsed >= duration;
+        return elapsed >= duration2;
       },
       step: (ms) => {
         elapsed += ms;
@@ -1186,8 +1664,8 @@ function mascotState(rows, {
   return rows.length && rows.every((row) => row.state === "gone") ? "gone" : "idle";
 }
 function countsLine(rows) {
-  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 ");
+  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;
@@ -1211,14 +1689,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);
@@ -1324,14 +1802,14 @@ function reportWords(report2, stopped) {
     return stopped ? "" : "ended without a report";
   return ["reported", report2.status].filter(Boolean).join(" ");
 }
-var counted = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+var counted = (count2, noun) => `${count2} ${noun}${count2 === 1 ? "" : "s"}`;
 var CONTEXT_WARN = 0.8;
 function activityParts(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.context !== undefined ? `ctx ${Math.round(row.context * 100)}%` : "", row.cost !== undefined ? `$${row.cost.toFixed(2)}` : ""].filter(Boolean);
+  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);
@@ -1354,7 +1832,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
@@ -1363,7 +1841,7 @@ function changes(ctx, types, settle) {
       return;
     settling = setTimeout(() => {
       settling = undefined;
-      setChanged((count) => count + 1);
+      setChanged((count2) => count2 + 1);
     }, settle);
   });
   return [changed, () => {
@@ -1489,8 +1967,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")
@@ -1501,7 +1979,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"
@@ -1518,7 +1996,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")
@@ -1534,7 +2012,7 @@ 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,
@@ -1545,6 +2023,7 @@ var digbyColours = (theme) => ({
   e: theme.text.feedback.error.base,
   s: theme.text.feedback.success.base
 });
+var DIGBY_UNDER = RGBA.fromValues(0, 0, 0, 0);
 function restBackground(theme, {
   selected,
   hovered
@@ -1682,7 +2161,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, {
@@ -1787,7 +2266,7 @@ function TreePanel(props) {
         _$insert(_el$5, () => one().char);
         _$effect((_$p) => _$setProp(_el$5, "style", {
           fg: one().fg && tokens[one().fg],
-          bg: one().bg && tokens[one().bg]
+          bg: one().bg ? tokens[one().bg] : DIGBY_UNDER
         }, _$p));
         return _el$5;
       })()
@@ -1996,7 +2475,7 @@ function TreePanel(props) {
           _$setProp(_el$29, "wrapMode", "none");
           _$setProp(_el$29, "flexShrink", 1);
           _$setProp(_el$29, "minWidth", 0);
-          _$insert(_el$29, () => oneLine(row.title), null);
+          _$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");
@@ -2115,7 +2594,8 @@ function TreePanel(props) {
   })();
 }
 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
@@ -2306,7 +2786,7 @@ function addTreePanel(ctx) {
     commands: [{
       id: "courier.command",
       title: "Courier",
-      description: USAGE,
+      description: usageWith(verbs),
       group: "Courier",
       slash: {
         name: "courier",
@@ -2318,9 +2798,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"
         });
       }
@@ -2390,7 +2873,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();