isorite 0.12.0 → 0.13.0

package/plugin/isorite.ts

@@ -1,65 +0,0 @@
-// The isorite server, as the plugin reaches it: over HTTP, as the browser does.
-// `isorite term` names it in ISORITE_URL.
-
-/** This harness's name as the server knows its agent. */
-export const AGENT = "opencode";
-
-export const url = (process.env.ISORITE_URL ?? "http://127.0.0.1:4767").replace(/\/$/, "");
-
-export interface Session { name: string; study: boolean; device: string; token: string }
-export interface Listing { notes: { id: string; title: string; dir: string }[]; dirs: string[] }
-
-/** A GET on the server's API; a refusal is thrown with the server's own words. */
-export async function get<T>(path: string): Promise<T> {
-  const response = await fetch(url + path);
-  const body = (await response.json().catch(() => ({}))) as T & { error?: string };
-  if (!response.ok) throw new Error(body.error ?? `${response.status} from ${url + path}`);
-  return body;
-}
-
-let token: Promise<string> | null = null;
-
-/** A POST to the server, made as its own page makes one: from its origin, with the token it hands out. */
-export async function post<T>(path: string, body: unknown): Promise<T> {
-  token ??= get<Session>("/api/session").then((s) => s.token, (e: Error) => { token = null; throw e; });
-  const response = await fetch(url + path, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", "x-isorite-token": await token, Origin: new URL(url).origin },
-    body: JSON.stringify(body),
-  });
-  const answer = (await response.json().catch(() => ({}))) as T & { error?: string };
-  if (!response.ok) throw new Error(answer.error ?? `${response.status} from ${url + path}`);
-  return answer;
-}
-
-/** A tool the server offers an agent, as OpenAI's API describes one. */
-export interface ToolDef { type: "function"; function: { name: string; description: string; parameters: Record<string, unknown> } }
-
-/** What the splash says of the base: its name and how many notes. */
-export async function base(): Promise<{ name: string; notes: number }> {
-  const [session, listing] = await Promise.all([get<Session>("/api/session"), get<Listing>("/api/notes")]);
-  return { name: session.name, notes: listing.notes.length };
-}
-
-/** The server's events, as the browser hears them, until the signal aborts; heard again after a dropped stream. */
-export function listen(on: (type: string, data: Record<string, unknown>) => void, signal: AbortSignal): void {
-  void (async () => {
-    while (!signal.aborted) {
-      try {
-        // As an agent: the server counts only browser pages as watching.
-        const response = await fetch(`${url}/api/events?agent=${AGENT}`, { signal });
-        const decoder = new TextDecoder();
-        let buffer = "";
-        for await (const chunk of response.body as unknown as AsyncIterable<Uint8Array>) {
-          buffer += decoder.decode(chunk, { stream: true });
-          for (let end; (end = buffer.indexOf("\n\n")) >= 0; buffer = buffer.slice(end + 2)) {
-            const block = buffer.slice(0, end);
-            const type = block.match(/^event: (.*)$/m)?.[1], data = block.match(/^data: (.*)$/m)?.[1];
-            if (type && data) { try { on(type, JSON.parse(data) as Record<string, unknown>); } catch { /* not ours */ } }
-          }
-        }
-      } catch { /* the server went; try again */ }
-      if (!signal.aborted) await new Promise((r) => setTimeout(r, 2000));
-    }
-  })();
-}

package/plugin/logo.ts

@@ -1,99 +0,0 @@
-// The isorite mark as `Terminal-Splash` draws it, in terminal cells.
-//
-// The board draws it on a grid 10 squares wide and 15 tall. Every shape is a full
-// square or a corner half of one, and a square is two cells wide and one row tall,
-// so the mark is 20 cells by 15 rows. The two top rows are in growth (gold), the
-// rest in the text colour.
-//
-// A corner half is drawn, by default, as one of Powerline's triangles in a square one
-// cell wide (`triangle`): terminals draw those themselves, from corner to corner and
-// meeting the full blocks (xterm.js and so VS Code, Windows Terminal, kitty, Ghostty,
-// WezTerm), where they leave ◢ ◣ ◤ ◥ to the font, which draws them inside the cell.
-// Its edges are straight, but as steep as a cell is tall (about 63°), not 45°: no
-// character a terminal draws itself makes a 45° edge. The other styles keep the
-// board's two-cell square: `legacy` draws a half with the wedges of Symbols for
-// Legacy Computing (45°, but the wedges split a cell in thirds, so an edge bends
-// where its cells meet, and xterm.js leaves them to the font); `quadrant` as a stair
-// of quarter blocks; `simple` as one font triangle and a space. `ISORITE_LOGO`
-// chooses.
-
-export type Corner = "tl" | "tr" | "bl" | "br";
-
-/** A square of the grid: whole, or a half with one corner left empty. */
-export interface Shape {
-  readonly x: number;
-  readonly y: number;
-  readonly empty?: Corner;
-  readonly growth?: boolean;
-}
-
-export type Style = "legacy" | "quadrant" | "simple" | "triangle";
-
-/** One run of cells in one colour. */
-export interface Run {
-  readonly text: string;
-  readonly growth: boolean;
-}
-
-export const width = 10;
-export const height = 15;
-
-const half = (x: number, y: number, empty: Corner, growth = false): Shape => ({ x, y, empty, growth });
-const full = (x: number, y: number, growth = false): Shape => ({ x, y, growth });
-
-// From the board's SVG: a triangle is named by the corner of its square that it leaves empty.
-export const shapes: readonly Shape[] = [
-  half(4, 0, "tl", true), full(5, 0, true), half(6, 0, "tr", true),
-  half(4, 1, "bl", true), full(5, 1, true), half(6, 1, "br", true),
-  half(9, 3, "br"), half(8, 3, "tl"),
-  half(8, 4, "br"), half(7, 4, "tl"),
-  half(7, 5, "br"), half(6, 5, "tl"),
-  half(6, 6, "br"), half(5, 6, "tl"),
-  half(0, 7, "bl"), half(1, 8, "bl"), half(2, 9, "bl"), half(3, 10, "bl"), half(4, 11, "bl"),
-  half(1, 7, "tr"), half(2, 8, "tr"), half(3, 9, "tr"), half(4, 10, "tr"),
-  full(5, 7), full(5, 8), full(5, 9), full(5, 10), full(5, 11), full(5, 12), full(5, 13), full(5, 14),
-];
-
-export const glyphs: Record<Style, Record<Corner | "full", string>> = {
-  // Each pair is one square: the left cell, then the right.
-  legacy: {
-    full: "██",
-    tl: "\u{1FB4A}\u{1FB42}", // lower right block, from the lower left to the upper right
-    tr: "\u{1FB4D}\u{1FB3F}", // lower left block, from the upper left to the lower right
-    bl: "\u{1FB63}\u{1FB55}", // upper right block, from the upper left to the lower right
-    br: "\u{1FB60}\u{1FB58}", // upper left block, from the lower left to the upper right
-  },
-  quadrant: { full: "██", tl: "▗▟", tr: "▙▖", bl: "▝▜", br: "▛▘" },
-  simple: { full: "██", tl: " ◢", tr: "◣ ", bl: " ◥", br: "◤ " },
-  // A square one cell: its halves straight from corner to corner, steeper than 45° as a cell is taller than wide.
-  // Powerline's triangles, which terminals draw themselves, edge to edge (xterm.js and so VS Code, Windows
-  // Terminal, kitty, Ghostty, WezTerm): ◢ ◣ ◥ ◤ are left to the font, which draws them inside the cell.
-  triangle: { full: "█", tl: "\u{E0BA}", tr: "\u{E0B8}", bl: "\u{E0BE}", br: "\u{E0BC}" },
-};
-
-/** A square of the style left empty: as many spaces as it is cells wide. */
-export function blank(style: Style): string {
-  return " ".repeat([...glyphs[style].full].length);
-}
-
-/** The mark's rows, each a list of runs, 10 cells wide in `triangle`, 20 in the others. */
-export function rows(style: Style = "quadrant"): Run[][] {
-  const grid: (Shape | undefined)[][] = Array.from({ length: height }, () => Array(width).fill(undefined));
-  for (const shape of shapes) grid[shape.y]![shape.x] = shape;
-  return grid.map((row) => {
-    const runs: Run[] = [];
-    for (const shape of row) {
-      const text = shape ? glyphs[style][shape.empty ?? "full"] : blank(style);
-      const growth = shape?.growth ?? false;
-      const last = runs.at(-1);
-      if (last && (last.growth === growth || !text.trim())) runs[runs.length - 1] = { text: last.text + text, growth: last.growth };
-      else runs.push({ text, growth });
-    }
-    return runs;
-  });
-}
-
-/** The mark as plain lines, for tests and for terminals without colour. */
-export function lines(style: Style = "quadrant"): string[] {
-  return rows(style).map((runs) => runs.map((run) => run.text).join(""));
-}

package/plugin/notepage.tsx

@@ -1,165 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-// A note in the terminal (`Terminal-Note`): its blocks behind a gutter of who wrote them, links underlined, maths as
-// source, code on its own ground, a figure offered in the browser; the changes waiting to be kept between dotted
-// rules, one of them current, with its keys.
-
-import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core";
-import type { Entry } from "../dist/core.js";
-import { For, Show, type Accessor } from "solid-js";
-import { agentName } from "../dist/core.js";
-import type { Ground } from "./palette.ts";
-import type { Item, Mark, ViewBlock, ViewChange } from "./noteview.ts";
-
-
-export interface NoteData {
-  id: string;
-  title: string;
-  /** The note's text, as it is (or was, at a moment of its timeline). */
-  text: string;
-  items: Item[];
-  /** At a moment of the timeline: what it was, and how long ago. Read only. */
-  at?: { said: string; ago: string };
-  entries: Entry[];
-}
-
-const DOTS = "· ".repeat(38).trim();
-/** The widest a note's column is: its gutter, rail and about 76 characters of text. */
-const MEASURE = 84;
-
-/** A note's path as the boards write it: "physics / softening". */
-export function pathOf(id: string, title: string): string {
-  return [...id.split("/").slice(0, -1).map((d) => d.replace(/-/g, " ")), title.toLowerCase()].join(" / ");
-}
-
-/** Who a change is from, as people say it. */
-export function fromWhom(who: string): string {
-  return who.startsWith("iso:") ? "Iso" : agentName(who) || "you";
-}
-
-/** A run of a line: plain, or a link's text, underlined. */
-function runs(line: string): { text: string; link: boolean }[] {
-  const out: { text: string; link: boolean }[] = [];
-  let at = 0;
-  for (const m of line.matchAll(/(?<!!)\[([^\]]+)\]\([^)]*\)/g)) {
-    if (m.index! > at) out.push({ text: line.slice(at, m.index), link: false });
-    out.push({ text: m[1]!, link: true });
-    at = m.index! + m[0].length;
-  }
-  if (at < line.length) out.push({ text: line.slice(at), link: false });
-  return out.length ? out : [{ text: line || " ", link: false }];
-}
-
-export function NotePage(props: { note: Accessor<NoteData | undefined>; current: Accessor<string>; cursor: Accessor<number>; asking: Accessor<boolean>; ground: Accessor<Ground>; base: string; scroll: (s: ScrollBoxRenderable) => void }) {
-  const g = () => props.ground();
-  const glyph = (mark: Mark | "waiting") =>
-    mark === "you" ? { c: "■", fg: g().lattice } : mark === "outside" ? { c: "□", fg: g().lattice } : mark === "iso" ? { c: "◆", fg: g().growth }
-      : mark === "agent" ? { c: "◆", fg: g().faint } : mark === "waiting" ? { c: "◇", fg: g().growth } : { c: " ", fg: g().faint };
-
-  /** One row: the gutter, the rail (blue beside the block the cursor is on), and what is on it. */
-  const Row = (p: { mark?: Mark | "waiting"; at?: boolean; children: unknown }) => (
-    <box flexDirection="row" minWidth={0}>
-      <text width={4} flexShrink={0} fg={glyph(p.mark ?? "").fg}>{` ${glyph(p.mark ?? "").c}  `}</text>
-      <box width={2} flexShrink={0} border={["left"]} borderColor={p.at ? g().lattice : g().line} />
-      <box flexGrow={1} minWidth={0} paddingLeft={1} flexDirection="column">{p.children as never}</box>
-    </box>
-  );
-  const Prose = (p: { text: string; bold?: boolean; fg?: string }) => (
-    <For each={p.text.split("\n")}>
-      {(line) => (
-        <text wrapMode="word" fg={p.fg ?? g().text} attributes={p.bold ? TextAttributes.BOLD : 0}>
-          <For each={runs(line)}>{(r) => (r.link ? <span style={{ fg: g().lattice, attributes: TextAttributes.UNDERLINE }}>{r.text}</span> : r.text)}</For>
-        </text>
-      )}
-    </For>
-  );
-  const Change = (p: { c: ViewChange }) => {
-    const on = () => props.current() === p.c.key;
-    return (
-      <box flexDirection="column">
-        <Row mark="waiting"><text fg={g().growth} wrapMode="none">{DOTS}</text></Row>
-        <Show when={!p.c.placed}><Row><text fg={g().faint} wrapMode="word">The place this was written for is no longer in the note.</text></Row></Show>
-        <Show when={p.c.old !== undefined}><Row><text fg={g().faint} wrapMode="word" attributes={TextAttributes.STRIKETHROUGH}>{p.c.old}</text></Row></Show>
-        <Row><Prose text={p.c.text.trim() || "(taken out)"} fg={on() ? g().text : g().soft} /></Row>
-        <Row>
-          <text wrapMode="none">
-            <span style={{ fg: g().growth }}>{`◆ ${fromWhom(p.c.who)}`}</span>
-            <span style={{ fg: g().faint }}>{" · not kept yet   "}</span>
-            <span style={{ fg: on() ? g().mal : g().faint }}>{"[k] keep  "}</span>
-            <span style={{ fg: on() ? g().growth : g().faint }}>{"[e] edit  "}</span>
-            <span style={{ fg: on() ? g().rose : g().faint }}>{"[r] remove"}</span>
-            <Show when={!on()}><span style={{ fg: g().faint }}>{"   [n] to choose it"}</span></Show>
-          </text>
-        </Row>
-        <Show when={p.c.asked}><Row><text fg={g().faint} wrapMode="word">{`“${p.c.asked}”`}</text></Row></Show>
-        <Row mark="waiting"><text fg={g().growth} wrapMode="none">{DOTS}</text></Row>
-        <Row><text> </text></Row>
-      </box>
-    );
-  };
-
-  const blockIndex = (item: Item) => props.note()?.items.filter((i) => i.type === "block").indexOf(item as ViewBlock) ?? -1;
-
-  return (
-    <box flexDirection="column" width="100%" height="100%" backgroundColor={g().g0}>
-      <Show when={props.note()} fallback={<text fg={g().faint} paddingLeft={4} paddingTop={1}>opening the note…</text>}>
-        {(note) => (
-          <>
-            <box flexDirection="row" paddingLeft={4} paddingRight={4} paddingTop={1} flexShrink={0}>
-              <text fg={g().text} wrapMode="none" flexShrink={1} minWidth={0}>{pathOf(note().id, note().title)}</text>
-              <Show when={note().at}>{(at) => <text fg={g().growth} wrapMode="none" flexShrink={1} minWidth={0}>{`   as it was ${at().ago}: ${at().said}`}</text>}</Show>
-              <box flexGrow={1} />
-            </box>
-            <scrollbox ref={props.scroll} flexGrow={1} paddingLeft={4} paddingRight={4} paddingTop={1} scrollbarOptions={{ visible: false }}>
-              {/* As the board: the text in a column of reading width, not the terminal's. */}
-              <box flexDirection="column" maxWidth={MEASURE}>
-                <For each={note().items}>
-                  {(item) => item.type === "change" ? <Change c={item} /> : (
-                    <box flexDirection="column" id={`block-${blockIndex(item)}`}>
-                      <Show when={item.kind === "code"} fallback={
-                        <Row mark={item.mark} at={blockIndex(item) === props.cursor()}>
-                          <Show when={item.kind === "figure"} fallback={
-                            <Show when={item.kind === "math"} fallback={<Prose text={item.text} bold={item.kind === "heading"} />}>
-                              <For each={item.text.split("\n")}>{(line) => <text wrapMode="word" fg={/^\$\$\s*$/.test(line) ? g().soft : g().text}>{line}</text>}</For>
-                            </Show>
-                          }>
-                            <text wrapMode="word">
-                              <span style={{ fg: g().faint }}>{`[ figure: ${/^!\[([^\]]*)\]/.exec(item.text)?.[1] || "untitled"} ]  `}</span>
-                              <span style={{ fg: g().lattice, attributes: TextAttributes.UNDERLINE }}>{"[b] see it in the browser"}</span>
-                            </text>
-                          </Show>
-                        </Row>
-                      }>
-                        <Row mark={item.mark} at={blockIndex(item) === props.cursor()}>
-                          <box backgroundColor={g().g1} flexDirection="column" paddingLeft={1}>
-                            <text fg={g().faint}>{/^(```|~~~)\s*(\S*)/.exec(item.text)?.[2] || "code"}</text>
-                            <For each={item.text.split("\n").slice(1, -1)}>{(line) => <text fg={g().text} wrapMode="none">{line || " "}</text>}</For>
-                          </box>
-                        </Row>
-                      </Show>
-                      <Row><text> </text></Row>
-                    </box>
-                  )}
-                </For>
-              </box>
-            </scrollbox>
-          </>
-        )}
-      </Show>
-      <box flexDirection="row" height={1} flexShrink={0} paddingLeft={4} paddingRight={4} backgroundColor={g().g1} gap={3}>
-        <text fg={g().g0} bg={g().text}> note </text>
-        <text fg={g().faint}>{props.base}</text>
-        <Show when={props.asking()}><text fg={g().growth}>◆ Iso is writing here</text></Show>
-        <box flexGrow={1} />
-        <Show when={props.note()?.items.some((i) => i.type === "change")}><text fg={g().faint}>[n] next change</text></Show>
-        <Show when={!props.note()?.at} fallback={<text fg={g().faint}>[q] back to now</text>}>
-          <text fg={g().faint}>[t] timeline</text>
-          <text fg={g().faint}>[/] ask in place</text>
-          <text fg={g().faint}>[a] its atlas</text>
-          <text fg={g().faint}>[s] send to agent</text>
-          <text fg={g().faint}>[b] browser</text>
-          <text fg={g().faint}>[q] back</text>
-        </Show>
-      </box>
-    </box>
-  );
-}

package/plugin/notes.ts

@@ -1,10 +0,0 @@
-// Which files are notes of the knowledge base: what the plugin hands to isorite rather than to OpenCode.
-
-import path from "node:path";
-
-/** Where a file is in the knowledge base, as a note's path, or null when it is not a note of it. */
-export function noteOf(notes: string | null, directory: string, file: unknown): string | null {
-  if (!notes || typeof file !== "string" || !file.toLowerCase().endsWith(".md")) return null;
-  const rel = path.relative(notes, path.resolve(directory, file));
-  return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? rel.split(path.sep).join("/") : null;
-}

package/plugin/noteview.ts

@@ -1,60 +0,0 @@
-// A note as the terminal draws it (`Terminal-Note`): its blocks, each marked in the gutter by who wrote most of it
-// (your square, an open square for a change made outside isorite, Iso's diamond, an agent's grey one), and the
-// changes waiting to be kept, each after the block it belongs to.
-
-import { authors, blocks, findPassage, locate, pending, type Entry } from "../dist/core.js";
-
-export type Mark = "you" | "outside" | "iso" | "agent" | "";
-export type Kind = "heading" | "math" | "code" | "figure" | "text";
-
-export interface ViewBlock { type: "block"; kind: Kind; text: string; mark: Mark }
-/** A change waiting to be kept: new text (`old` absent), or a passage rewritten. `key` names it to keep or remove. */
-export interface ViewChange { type: "change"; key: string; proposal: string; region?: number; who: string; asked: string; old?: string; text: string; placed: boolean }
-export type Item = ViewBlock | ViewChange;
-
-export function markOf(who: string): Mark {
-  return who === "you" ? "you" : who === "external" ? "outside" : who.startsWith("iso:") ? "iso" : who.startsWith("agent:") ? "agent" : "";
-}
-
-function kindOf(text: string): Kind {
-  return /^#{1,6}\s/.test(text) ? "heading" : text.startsWith("$$") ? "math" : /^(```|~~~)/.test(text) ? "code" : /^!\[[^\]]*\]\([^)]*\)\s*$/.test(text) ? "figure" : "text";
-}
-
-/** The note's blocks and its waiting changes, in reading order. */
-export function noteView(text: string, entries: readonly Entry[]): Item[] {
-  const all = blocks(text), owners = authors(entries);
-  // A block's mark: who wrote the most of its lines, the later writer on a tie.
-  const marked = all.map((b): ViewBlock => {
-    const counts = new Map<string, number>();
-    for (let line = b.from; line < b.to; line++) { const who = owners?.[line]; if (who) counts.set(who, (counts.get(who) ?? 0) + 1); }
-    let best = "", most = 0;
-    for (const [who, n] of counts) if (n >= most) { best = who; most = n; }
-    return { type: "block", kind: kindOf(b.text), text: b.text, mark: best ? markOf(best) : "" };
-  });
-  // Each change after the block it belongs to; one whose place is gone, at the end.
-  const after = new Map<number, ViewChange[]>(), end: ViewChange[] = [];
-  const put = (line: number | null, c: ViewChange) => {
-    if (line === null) { end.push(c); return; }
-    let k = -1;
-    for (let i = 0; i < all.length; i++) if (all[i]!.from <= line) k = i;
-    after.set(k, [...(after.get(k) ?? []), c]);
-  };
-  const lineOf = (char: number) => text.slice(0, char).split("\n").length - 1;
-  for (const p of pending([...entries])) {
-    const base = { type: "change" as const, proposal: p.id, who: p.who, asked: p.asked };
-    if (p.form === "insert") {
-      const at = locate(text, p);
-      // An insert goes at a line between blocks: it belongs after the block that ends there.
-      const line = at?.form === "insert" ? at.line - 1 : null;
-      put(line, { ...base, key: `p:${p.id}`, text: p.text, placed: line !== null });
-      continue;
-    }
-    for (const k of p.open ?? p.regions.map((_, i) => i)) {
-      const region = p.regions[k]!, at = findPassage(text, region.old);
-      put(at ? lineOf(at.from) : null, { ...base, key: `${p.id}:${k}`, region: k, old: region.old.text, text: region.new, placed: at !== null });
-    }
-  }
-  const out: Item[] = [...(after.get(-1) ?? [])];
-  marked.forEach((b, k) => { out.push(b, ...(after.get(k) ?? [])); });
-  return [...out, ...end];
-}

package/plugin/oneatlas.ts

@@ -1,83 +0,0 @@
-// One note's Atlas in terminal cells (`Terminal-Atlas`): what it requires on the left, the note in the middle, what
-// builds on it on the right, each a box of two lines of title, joined by routes. The neighbourhood is the core's
-// `reach`, as the browser's Atlas lights a chosen note; only the drawing is the terminal's.
-
-export type Role = "text" | "faint" | "ls" | "req" | "bld" | "gold" | "blank";
-export interface Cell { ch: string; role: Role; bold?: boolean }
-export interface Box { id: string; title: string; gold?: boolean }
-
-export const GAP = 5;
-const BOX_H = 4, STEP = BOX_H + 1;
-
-/** A title in two lines of a box's width, cut with an ellipsis past that. */
-export function wrapTitle(title: string, width: number): [string, string] {
-  const words = title.split(/\s+/).filter(Boolean), lines: string[] = [""];
-  for (const w of words) {
-    const last = lines[lines.length - 1]!;
-    if (!last) lines[lines.length - 1] = w;
-    else if (last.length + 1 + w.length <= width) lines[lines.length - 1] = `${last} ${w}`;
-    else lines.push(w);
-  }
-  const cut = (s: string) => (s.length > width ? s.slice(0, width - 1) + "…" : s);
-  if (lines.length > 2) return [cut(lines[0]!), cut(lines.slice(1).join(" ")).slice(0, width - 1) + "…"];
-  return [cut(lines[0] ?? ""), cut(lines[1] ?? "")];
-}
-
-// Box drawing by which sides a cell joins: up, down, left, right.
-const JOIN: Record<string, string> = {
-  "0011": "─", "1100": "│", "0101": "┌", "0110": "┐", "1001": "└", "1010": "┘",
-  "1101": "├", "1110": "┤", "0111": "┬", "1011": "┴", "1111": "┼", "0001": "─", "0010": "─", "1000": "│", "0100": "│",
-};
-
-/** The grid of cells for a note and its neighbours, `width` cells wide. */
-export function drawAtlas(me: Box, requires: Box[], builds: Box[], width: number): Cell[][] {
-  const col = Math.max(12, Math.min(24, Math.floor((width - 2 * GAP) / 3)));
-  const rows = Math.max(BOX_H, requires.length * STEP - 1, builds.length * STEP - 1);
-  const W = 3 * col + 2 * GAP;
-  const grid: Cell[][] = Array.from({ length: rows }, () => Array.from({ length: W }, (): Cell => ({ ch: " ", role: "blank" })));
-  const put = (x: number, y: number, ch: string, role: Role, bold = false) => { if (grid[y]?.[x]) grid[y]![x] = { ch, role, ...(bold ? { bold } : {}) }; };
-
-  const box = (x: number, y: number, b: Box, kind: "plain" | "me" | "dashed") => {
-    const [h, v, c] = kind === "me" ? ["━", "┃", "┏┓┗┛"] : kind === "dashed" ? ["╌", "╎", "┌┐└┘"] : ["─", "│", "┌┐└┘"];
-    const role: Role = b.gold ? "gold" : kind === "me" ? "text" : "ls";
-    for (let i = 1; i < col - 1; i++) { put(x + i, y, h, role, kind === "me"); put(x + i, y + BOX_H - 1, h, role, kind === "me"); }
-    for (let j = 1; j < BOX_H - 1; j++) { put(x, y + j, v, role, kind === "me"); put(x + col - 1, y + j, v, role, kind === "me"); }
-    put(x, y, c[0]!, role, kind === "me"); put(x + col - 1, y, c[1]!, role, kind === "me");
-    put(x, y + BOX_H - 1, c[2]!, role, kind === "me"); put(x + col - 1, y + BOX_H - 1, c[3]!, role, kind === "me");
-    wrapTitle(b.title, col - 4).forEach((line, j) => [...line].forEach((ch, i) => put(x + 2 + i, y + 1 + j, ch, kind === "me" ? "text" : b.gold ? "gold" : "text", kind === "me")));
-  };
-
-  // A side's routes, in the gap between its boxes (their edge at `boxes`) and the note (its edge at `note`): each
-  // box's middle row to a trunk in the middle of the gap, and the trunk to the note's middle row.
-  const routes = (rowsOf: number[], boxes: number, note: number, role: Role) => {
-    if (!rowsOf.length) return;
-    const trunk = Math.floor((boxes + note) / 2), at = new Map<string, number[]>();
-    const join = (x: number, y: number, k: number) => { const j = at.get(`${x},${y}`) ?? [0, 0, 0, 0]; j[k] = 1; at.set(`${x},${y}`, j); };
-    const across = (y: number, a: number, b: number) => { for (let x = Math.min(a, b); x <= Math.max(a, b); x++) { if (x > Math.min(a, b)) join(x, y, 2); if (x < Math.max(a, b)) join(x, y, 3); } };
-    const down = (x: number, a: number, b: number) => { for (let y = Math.min(a, b); y <= Math.max(a, b); y++) { if (y > Math.min(a, b)) join(x, y, 0); if (y < Math.max(a, b)) join(x, y, 1); } };
-    for (const y of rowsOf) { across(y, boxes, trunk); down(trunk, y, mid); }
-    across(mid, trunk, note);
-    for (const [key, j] of at) { const [x, y] = key.split(",").map(Number) as [number, number]; put(x, y, JOIN[j.join("")] ?? "┼", role); }
-  };
-
-  const top = (n: number) => Math.floor((rows - (n * STEP - 1)) / 2);
-  const meY = Math.floor((rows - BOX_H) / 2), mid = meY + 1;
-  const leftTop = top(requires.length), rightTop = top(builds.length);
-  routes(requires.map((_, k) => leftTop + k * STEP + 1), col, col + GAP - 1, "req");
-  routes(builds.map((_, k) => rightTop + k * STEP + 1), 2 * col + 2 * GAP - 1, 2 * col + GAP, "bld");
-  requires.forEach((b, k) => box(0, leftTop + k * STEP, b, "plain"));
-  builds.forEach((b, k) => box(2 * col + 2 * GAP, rightTop + k * STEP, b, "dashed"));
-  box(col + GAP, meY, me, "me");
-  return grid;
-}
-
-/** A row of cells as runs of one role, for drawing. */
-export function runsOf(row: Cell[]): { text: string; role: Role; bold: boolean }[] {
-  const out: { text: string; role: Role; bold: boolean }[] = [];
-  for (const c of row) {
-    const last = out.at(-1), bold = c.bold ?? false;
-    if (last && last.role === c.role && last.bold === bold) last.text += c.ch;
-    else out.push({ text: c.ch, role: c.role, bold });
-  }
-  return out;
-}

package/plugin/palette.ts

@@ -1,21 +0,0 @@
-// The boards' two grounds (`isorite.css` on the mood board): lapis, dark, and quartz, light.
-
-export const lapis = {
-  g0: "#07101C", g1: "#0C1828", g2: "#122238", g3: "#1A3150", line: "#23395A", ls: "#5C7BA6",
-  text: "#E9EEF5", soft: "#B4C0D2", faint: "#8796AD",
-  lattice: "#6BA6FF", growth: "#F0BE4A", mal: "#5FD3A4", rose: "#FF8FA6",
-} as const;
-
-export const quartz = {
-  g0: "#F2F0EA", g1: "#F8F7F3", g2: "#FFFFFF", g3: "#E6E4DC", line: "#D3D0C5", ls: "#7F7D70",
-  text: "#0E1726", soft: "#3B475B", faint: "#5B677A",
-  lattice: "#1E4FB8", growth: "#8C6200", mal: "#0B6B4A", rose: "#A81E48",
-} as const;
-
-export type Swatch = keyof typeof lapis;
-
-/** A ground: a colour for each swatch, lapis's or quartz's. */
-export type Ground = Record<Swatch, string>;
-
-/** The one-note Atlas's routes: what a note requires, and what builds on it (`Terminal-Atlas`). */
-export const routeColours = { lapis: { req: "#B79CFF", bld: "#FF9E64" }, quartz: { req: "#6A3FC0", bld: "#B5521B" } } as const;

package/plugin/play.ts

@@ -1,104 +0,0 @@
-// The notes in play in a session: what the agent's look-ups found, what it reached along links from them, and how
-// far each got (found and not opened, looked at, read, or used in an answer). Drawn as a tree, as `Terminal-Chat`
-// draws the notes found, in the sidebar.
-
-/** One step, as the isorite server publishes it (the engine's Step). */
-export interface Step {
-  tool: string;
-  how: "keyword" | "meaning" | "link" | "read";
-  notes: string[];
-  opened?: string;
-  from?: string;
-  rel?: string;
-  query?: string;
-  scores?: Record<string, number>;
-  failed?: boolean;
-}
-
-export type State = "not opened" | "looked at" | "read" | "used";
-const RANK: Record<State, number> = { "not opened": 0, "looked at": 1, read: 2, used: 3 };
-
-export interface InPlay {
-  id: string;
-  how: Step["how"];
-  /** How it was found: the words searched for, or how alike in meaning. */
-  query?: string;
-  score?: number;
-  /** For a note reached along a link: the note it was reached from, and what the link says. */
-  from?: string;
-  rel?: string;
-  state: State;
-}
-
-export interface Row {
-  /** The tree's lines before it: "├─ ", "│  └─ ". */
-  prefix: string;
-  id: string;
-  /** What it is called, and how it came: `keyword "mixing"`, `meaning 0.81`, `requires ›`. */
-  label: string;
-  detail: string;
-  state: State;
-}
-
-export class Play {
-  private readonly notes = new Map<string, InPlay>();
-
-  /** Takes in one of the agent's steps. */
-  add(step: Step): void {
-    if (step.failed) return;
-    if (step.tool === "search_notes" || step.tool === "find_similar") {
-      for (const id of step.notes) {
-        if (this.notes.has(id)) continue;
-        const score = step.scores?.[id];
-        this.notes.set(id, { id, how: step.how, ...(step.query ? { query: step.query } : {}), ...(score === undefined ? {} : { score }), state: "not opened" });
-      }
-      return;
-    }
-    if (!step.opened) return;
-    const known = this.notes.get(step.opened);
-    const reached: InPlay = known ?? { id: step.opened, how: step.how, ...(step.from ? { from: step.from } : {}), ...(step.rel ? { rel: step.rel } : {}), state: "not opened" };
-    this.notes.set(step.opened, { ...reached, state: this.higher(reached.state, step.tool === "outline_note" ? "looked at" : "read") });
-  }
-
-  /** The notes an answer cites are used. Whether any was not used before. */
-  cite(ids: Iterable<string>): boolean {
-    let changed = false;
-    for (const id of ids) {
-      const known = this.notes.get(id);
-      if (known && known.state !== "used") { this.notes.set(id, { ...known, state: "used" }); changed = true; }
-    }
-    return changed;
-  }
-
-  get size(): number { return this.notes.size; }
-
-  /** How many were found by searching, how many more by following links, how many used. */
-  summary(): { found: number; followed: number; used: number } {
-    const all = [...this.notes.values()];
-    return { found: all.filter((n) => !n.from).length, followed: all.filter((n) => n.from).length, used: all.filter((n) => n.state === "used").length };
-  }
-
-  /** The tree, a row a note: those found at the top in the order found, each with what was reached from it beneath. */
-  rows(title: (id: string) => string): Row[] {
-    const all = [...this.notes.values()];
-    const under = (parent: string | undefined) => all.filter((n) => (n.from && this.notes.has(n.from) ? n.from : undefined) === parent);
-    const out: Row[] = [];
-    const walk = (parent: string | undefined, lead: string) => {
-      const kids = under(parent);
-      kids.forEach((n, k) => {
-        const last = k === kids.length - 1;
-        const named = title(n.id).toLowerCase();
-        out.push({
-          prefix: lead + (last ? "└─ " : "├─ "), id: n.id, state: n.state,
-          label: n.from ? `${n.rel ?? "links to"} › ${named}` : named,
-          detail: n.from ? "" : n.how === "meaning" ? `meaning${n.score === undefined ? "" : ` ${n.score.toFixed(2)}`}` : n.how === "keyword" ? `keyword${n.query ? ` "${n.query}"` : ""}` : "",
-        });
-        walk(n.id, lead + (last ? "   " : "│  "));
-      });
-    };
-    walk(undefined, "");
-    return out;
-  }
-
-  private higher(a: State, b: State): State { return RANK[b] > RANK[a] ? b : a; }
-}