@saadnvd1/agent-os 0.3.457 → 0.3.459

package/README.md

@@ -78,8 +78,10 @@ conversation in **Messages** and can join in. [More](#agent-network)
 
 - **Chat or terminal, same conversation.** Streaming replies, steps and
   diffs, plan mode, a queue you can steer, slash commands and skills,
-  `@file`, undo, and inline charts and pages. One click hands the
-  conversation to the agent's own terminal. [More](#chat)
+  `@file`, undo, and inline charts and pages. ⌘F (Ctrl+F) finds text
+  anywhere in the conversation, tool output and older pages included, and
+  opens the step it's in. One click hands the conversation to the agent's
+  own terminal. [More](#chat)
 - **Project config.** `agentos.json` (or an existing `.dispatch.json`) gives
   each session its own ports, environment, copied files, cloned
   dependencies, a private Postgres copy, and a "Running this project"
@@ -842,7 +844,7 @@ it may do on its own, and the lines that always come back to you as asks.
   stack position), `read` (the end of a terminal or chat) and `cards` (the
   linked boards' cards), plus acting tools: `send`, `start_task`,
   `start_session`, `stack`, `stack_status`, `land`, `drop`, `stop`, `done`, `note`,
-  `review`, `sign_off`, `arm`, `disarm` and `ask_saad`. All are served in-process to its chat, refuse
+  `rule_add`, `rule_remove`, `review`, `sign_off`, `arm`, `disarm` and `ask_saad`. All are served in-process to its chat, refuse
   any target outside its workspace, and validate their arguments. The one
   exception is other orchestrators: `orchestrators` lists every workspace and
   whether it has one, and `message_orchestrator` messages another workspace's
@@ -916,6 +918,28 @@ it may do on its own, and the lines that always come back to you as asks.
   again needs your passkey.
 - **Decision log:** `note` and the brakes and escalations write to
   `orchestrator_notes`, and each line shows in its chat.
+- **Standing rules:** what it must keep knowing ("never merge #111", "briefs
+  must not name competitors") it keeps with `rule_add` and drops with
+  `rule_remove`, in `orchestrator_rules`. You see, add, edit and remove them in
+  Settings → Workspaces, each change with your passkey (any process on the
+  machine reaches the route, and a rule of yours is your word to it). A rule restricts or informs; it never approves an
+  ask, passes a gate or clears a hard line. Yours are marked as from you and
+  only you remove them; the ones it kept, like its decision-log lines, come
+  back to it fenced as its own notes, so text it read can't pass for your
+  word. Rule text is redacted when stored, and removed rules stay on record.
+- **Where things stand:** every start appends a digest read straight from
+  the database, no model involved: the standing rules, open asks, running
+  tasks with their PR, armed-to-merge and gate state, recently gated external
+  PRs, the queue, schedules and the newest decision-log lines, capped at about
+  4k tokens. The brief tells it this is authoritative over what it remembers.
+- **Fresh starts:** fed events nonstop, an orchestrator never idles and can't
+  compact itself. Once its context passes a threshold (200k tokens by
+  default, Settings → Workspaces → Fresh starts), its worker ends the
+  conversation at the next turn boundary and the next one starts a new
+  conversation with the brief and digest, telling the agent in one line why.
+  Nothing is lost, because its state lives in the database; its chat goes on,
+  with a line where it started over. The same can be switched on for chat
+  tasks (off by default: a task keeps only its brief and its branch).
 - **Events:** the server sends it one short line per event (a PR opened, CI
   failed, or green once it has settled so `sign_off`'s ci gate passes, a `BLOCKED:` line, a merge, a session needing input, a
   stack step, a task idle 30 minutes with no PR, a review's verdict). Events
@@ -948,8 +972,9 @@ approved`). An approval covers that one item only: a held task's approval
   filed as that hard line.
 - **Proof it's you:** only this machine, the tailnet, or a paired device you
   switched to "Can approve" in Devices may answer asks or pause. Approving a
-  hard line, a gate, a brake or a new passkey, Resume, and switching merge
-  approvals off, also need a
+  hard line, a gate, a brake or a new passkey, Resume, changing the
+  orchestrator's standing rules, and switching merge approvals off, also
+  need a
   passkey (Touch ID or Face ID, user verification required) on a challenge
   bound to that one ask at its current commit or brake: single use, two
   minutes. Agents on this machine reach every route but can't make your

package/app/api/fresh-start/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { refreshSettings, setRefreshSettings } from "@/lib/chat/refresh";
+
+// When a chat's conversation starts over (lib/chat/refresh): context
+// tokens for orchestrators and for tasks, 0 for never.
+export async function GET() {
+  return NextResponse.json(refreshSettings());
+}
+
+export async function PUT(request: NextRequest) {
+  try {
+    const { orchestratorTokens, taskTokens } = await request.json();
+    setRefreshSettings({ orchestratorTokens, taskTokens });
+    return NextResponse.json(refreshSettings());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/api/workspaces/[id]/orchestrator/rules/[ruleId]/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from "next/server";
+import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import { removeRule, updateRule } from "@/lib/orchestrator/rules";
+import { provenAsSaad } from "../presence";
+
+type RouteParams = { params: Promise<{ id: string; ruleId: string }> };
+
+type Body = { text?: unknown; assertion?: AuthenticationResponseJSON };
+
+// The rule, its body, and Saad's passkey on it; or the refusal.
+async function target(
+  request: NextRequest,
+  { params }: RouteParams
+): Promise<
+  { response: Response } | { workspaceId: string; ruleId: number; body: Body }
+> {
+  const { id, ruleId } = await params;
+  const n = Number(ruleId);
+  if (!Number.isInteger(n) || n <= 0)
+    return {
+      response: NextResponse.json({ error: "Bad rule id" }, { status: 400 }),
+    };
+  const body = (await request.json().catch(() => ({}))) as Body;
+  const refused = await provenAsSaad(request, id, body.assertion);
+  if (refused) return { response: refused };
+  return { workspaceId: id, ruleId: n, body };
+}
+
+const refused = (error: unknown) =>
+  NextResponse.json(
+    { error: error instanceof Error ? error.message : String(error) },
+    { status: 400 }
+  );
+
+// { text, assertion }: Saad rewords a rule.
+export async function PATCH(request: NextRequest, ctx: RouteParams) {
+  const t = await target(request, ctx);
+  if ("response" in t) return t.response;
+  if (typeof t.body.text !== "string")
+    return NextResponse.json({ error: "text is required" }, { status: 400 });
+  try {
+    return NextResponse.json({
+      rule: updateRule(t.workspaceId, t.ruleId, t.body.text),
+    });
+  } catch (error) {
+    return refused(error);
+  }
+}
+
+// { assertion }: marked removed, never deleted.
+export async function DELETE(request: NextRequest, ctx: RouteParams) {
+  const t = await target(request, ctx);
+  if ("response" in t) return t.response;
+  try {
+    removeRule(t.workspaceId, t.ruleId, "saad");
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return refused(error);
+  }
+}

package/app/api/workspaces/[id]/orchestrator/rules/presence.ts

@@ -0,0 +1,29 @@
+import type { NextRequest } from "next/server";
+import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import { requireApprover } from "@/lib/security/approver";
+import { relyingParty, verifyPresence } from "@/lib/security/presence";
+import { refusalResponse } from "@/lib/security/presence-http";
+import { rulesPresence } from "@/lib/orchestrator/presence-binding";
+
+// A rule written here is Saad's, shown to the orchestrator as his word and
+// removable only by him: so it takes his passkey, not just a trusted place
+// (any process on this machine reaches the route).
+export async function provenAsSaad(
+  request: NextRequest,
+  workspaceId: string,
+  assertion: AuthenticationResponseJSON | undefined
+): Promise<Response | null> {
+  const gate = requireApprover(request);
+  if (!gate.ok) return gate.response;
+  try {
+    await verifyPresence(
+      relyingParty(request.headers),
+      assertion,
+      "rules",
+      rulesPresence(workspaceId)
+    );
+    return null;
+  } catch (error) {
+    return refusalResponse(error);
+  }
+}

package/app/api/workspaces/[id]/orchestrator/rules/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from "next/server";
+import type { AuthenticationResponseJSON } from "@simplewebauthn/server";
+import { getWorkspace } from "@/lib/workspaces";
+import { addRule, listRules } from "@/lib/orchestrator/rules";
+import { provenAsSaad } from "./presence";
+
+type RouteParams = { params: Promise<{ id: string }> };
+
+// The workspace orchestrator's standing rules, in its brief on every start.
+export async function GET(_request: NextRequest, { params }: RouteParams) {
+  const { id } = await params;
+  if (!getWorkspace(id))
+    return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
+  return NextResponse.json({ rules: listRules(id) });
+}
+
+// { text, assertion }: a rule from Saad, with his passkey.
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  const { id } = await params;
+  if (!getWorkspace(id))
+    return NextResponse.json({ error: "Workspace not found" }, { status: 404 });
+  const { text, assertion } = (await request.json().catch(() => ({}))) as {
+    text?: unknown;
+    assertion?: AuthenticationResponseJSON;
+  };
+  if (typeof text !== "string")
+    return NextResponse.json({ error: "text is required" }, { status: 400 });
+  const refused = await provenAsSaad(request, id, assertion);
+  if (refused) return refused;
+  try {
+    return NextResponse.json({ rule: addRule(id, text, "saad") });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/app/globals.css

@@ -252,3 +252,13 @@ body {
   color: hsl(var(--primary));
   animation: status-pulse 1s ease-in-out infinite;
 }
+
+/* Find in a conversation (components/Chat/find-highlight): every match, and
+   the one it's on, in the browser's own find colours (styles/themes.css). */
+::highlight(chat-find) {
+  background-color: hsl(var(--find-match));
+}
+::highlight(chat-find-current) {
+  background-color: hsl(var(--find-current));
+  color: hsl(var(--find-current-foreground));
+}

package/components/Chat/ChatPanel.tsx

@@ -28,7 +28,9 @@ import { Composer } from "./Composer";
 import { Queue } from "./Queue";
 import { QuoteButton } from "./QuoteButton";
 import { ToolBodies, ToolGroup } from "./Tools";
-import { RowState } from "./rowState";
+import { RowState, RowStore } from "./rowState";
+import { FindBar } from "./FindBar";
+import { FIND_EVENT, isFindKey, useFind } from "./useFind";
 import { McpServers } from "./McpServers";
 import { ArtifactCard } from "./Artifact";
 import { PlanCard } from "./PlanCard";
@@ -159,7 +161,9 @@ const Block = memo(
         <Timeline blocks={groupTimeline(b.items)} actions={undoneActions} />
       </UndoneBlock>
     ) : (
-      <Item item={b.item} actions={actions} />
+      <div data-item={b.item.id}>
+        <Item item={b.item} actions={actions} />
+      </div>
     );
   },
   (prev, next) =>
@@ -221,6 +225,7 @@ export function ChatPanel({
     queueSendNow,
     suggestion,
     requestFiles,
+    search,
   } = useChat(sessionId, (text) => setPrefill({ text, at: Date.now() }));
   const { isMobile } = useViewport();
   const scrollRef = useRef<HTMLDivElement>(null);
@@ -231,6 +236,7 @@ export function ChatPanel({
     stuck,
     unread,
     toBottom: toEnd,
+    release,
   } = useStickToBottom(listRef, sessionId, arrivalKey(items.at(-1)));
 
   const running = state === "running" || state === "waiting";
@@ -253,6 +259,8 @@ export function ChatPanel({
     const onKey = (e: KeyboardEvent) => {
       const root = rootRef.current;
       if (!root?.contains(e.target as Node)) return;
+      // The find bar takes its own Esc.
+      if ((e.target as Element).closest?.("[data-find-bar]")) return;
       const overlay = !!document.querySelector(OVERLAY_SELECTOR);
       const ghost = !!root.querySelector(GHOST_SELECTOR);
       const action = escapeAction(e, escape.current.running, overlay, ghost);
@@ -317,11 +325,72 @@ export function ChatPanel({
   }, [earlierTasks, items]);
   // A new conversation starts with every row closed.
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  const rowState = useMemo(() => new Map<string, unknown>(), [sessionId]);
+  const rowState = useMemo(() => new RowStore(), [sessionId]);
   const bodies = useMemo(
     () => ({ bodies: toolBodies, request: requestToolBody, connected }),
     [toolBodies, requestToolBody, connected]
   );
+  const blocksRef = useRef(blocks);
+  useEffect(() => {
+    blocksRef.current = blocks;
+  });
+  const find = useFind({
+    search,
+    items,
+    hasMore,
+    loadingOlder,
+    loadOlder,
+    rows: rowState,
+    release,
+    scrollToBlock: useCallback(async (key: string) => {
+      const index = blocksRef.current.findIndex((b) => blockKey(b) === key);
+      if (index !== -1)
+        await listRef.current?.scrollToIndex({
+          index,
+          viewPosition: 0.3,
+          animated: false,
+        });
+    }, []),
+    scroller: useCallback(() => {
+      const el = listRef.current?.getScrollableNode();
+      return el instanceof HTMLElement ? el : null;
+    }, []),
+  });
+  const activeRef = useRef(active);
+  useEffect(() => {
+    activeRef.current = active;
+  });
+  // ⌘F (Ctrl+F off a Mac) in this chat, or the phone header's search
+  // button, opens the find bar; pressed again, the field takes the caret.
+  const [findFocus, setFindFocus] = useState(0);
+  const showFind = find.show;
+  const closeFind = find.close;
+  useEffect(() => {
+    const open = () => {
+      showFind();
+      setFindFocus((n) => n + 1);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      const root = rootRef.current;
+      const here =
+        root?.contains(e.target as Node) ||
+        (activeRef.current && e.target === document.body);
+      if (!here || !isFindKey(e)) return;
+      e.preventDefault();
+      open();
+    };
+    const onFind = (e: Event) => {
+      if ((e as CustomEvent<string>).detail === sessionId) open();
+    };
+    window.addEventListener("keydown", onKey, true);
+    window.addEventListener(FIND_EVENT, onFind);
+    return () => {
+      window.removeEventListener("keydown", onKey, true);
+      window.removeEventListener(FIND_EVENT, onFind);
+    };
+  }, [sessionId, showFind]);
+  // Another conversation starts without the last one's find.
+  useEffect(() => closeFind, [sessionId, closeFind]);
   const idle = !running && connected;
   const actions: ItemActions = useMemo(
     () => ({
@@ -354,7 +423,10 @@ export function ChatPanel({
               keyExtractor={blockKey}
               getItemType={blockType}
               renderItem={({ item }) => (
-                <div className="mx-auto w-full max-w-3xl px-4 pb-4">
+                <div
+                  data-block={blockKey(item)}
+                  className="mx-auto w-full max-w-3xl px-4 pb-4"
+                >
                   <Block block={item} actions={actions} />
                 </div>
               )}
@@ -394,6 +466,17 @@ export function ChatPanel({
             />
           </ToolBodies.Provider>
         </RowState.Provider>
+        {find.open && (
+          <FindBar
+            find={find}
+            focusKey={findFocus}
+            onClose={(fromKey) => {
+              closeFind();
+              // A tap on a phone would bring up the keyboard over the match.
+              if (fromKey || !isMobile) focusComposer();
+            }}
+          />
+        )}
         {unread && !stuck && (
           <button
             type="button"

package/components/Chat/FindBar.tsx

@@ -0,0 +1,113 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { ChevronDown, ChevronUp, Loader2, X } from "lucide-react";
+import { MIN_QUERY } from "@/lib/chat/find";
+import type { useFind } from "./useFind";
+
+type Find = ReturnType<typeof useFind>;
+
+const iconButton =
+  "text-muted-foreground hover:text-foreground hover:bg-foreground/[0.06] flex h-11 w-11 shrink-0 items-center justify-center rounded-md disabled:pointer-events-none disabled:opacity-40 md:h-7 md:w-7";
+
+function Count({ find }: { find: Find }) {
+  if (find.query.trim().length < MIN_QUERY) return null;
+  if (find.status === "searching")
+    return (
+      <Loader2 className="h-3.5 w-3.5 animate-spin" aria-label="Searching" />
+    );
+  if (find.status === "unavailable") return <span>Unavailable</span>;
+  if (!find.total) return <span>No results</span>;
+  return (
+    <span>
+      {find.position} of {find.total}
+      {find.capped && "+"}
+    </span>
+  );
+}
+
+// Find in the conversation: a small bar over the top of the chat. Enter goes
+// to the next match up the conversation, Shift+Enter back down, Esc closes.
+export function FindBar({
+  find,
+  focusKey,
+  onClose,
+}: {
+  find: Find;
+  // Changes whenever ⌘F is pressed again: the field takes the caret back.
+  focusKey: number;
+  // `fromKey`: closed with Esc, so the caret goes back to the composer.
+  onClose: (fromKey: boolean) => void;
+}) {
+  const input = useRef<HTMLInputElement>(null);
+  useEffect(() => {
+    input.current?.focus();
+    input.current?.select();
+  }, [focusKey]);
+  const none = !find.total;
+  return (
+    <div
+      data-find-bar
+      role="search"
+      className="bg-background absolute top-2 right-2 left-2 z-20 flex items-center gap-1 rounded-lg border py-0.5 pr-0.5 pl-3 shadow-sm md:left-auto md:w-96"
+    >
+      <input
+        ref={input}
+        value={find.query}
+        onChange={(e) => find.setQuery(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && !e.nativeEvent.isComposing) {
+            e.preventDefault();
+            if (e.shiftKey) find.previous();
+            else find.next();
+          } else if (e.key === "Escape") {
+            e.preventDefault();
+            onClose(true);
+          }
+        }}
+        placeholder="Find in conversation"
+        aria-label="Find in conversation"
+        enterKeyHint="search"
+        autoComplete="off"
+        spellCheck={false}
+        // 16px on phones, so iOS doesn't zoom in on focus.
+        className="placeholder:text-muted-foreground min-w-0 flex-1 bg-transparent py-1.5 text-base outline-none md:text-sm"
+      />
+      <span
+        aria-live="polite"
+        className="text-muted-foreground shrink-0 px-1 font-mono text-[11px] tabular-nums"
+      >
+        <Count find={find} />
+      </span>
+      <button
+        type="button"
+        onClick={find.next}
+        disabled={none}
+        aria-label="Next match, further up"
+        title="Next (Enter)"
+        className={iconButton}
+      >
+        <ChevronUp className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        onClick={find.previous}
+        disabled={none}
+        aria-label="Previous match, further down"
+        title="Previous (Shift+Enter)"
+        className={iconButton}
+      >
+        <ChevronDown className="h-4 w-4" />
+      </button>
+      <button
+        type="button"
+        onClick={() => onClose(false)}
+        aria-label="Close find"
+        title="Close (Esc)"
+        className={iconButton}
+      >
+        <X className="h-4 w-4" />
+      </button>
+    </div>
+  );
+}

package/components/Chat/Tools.tsx

@@ -132,7 +132,7 @@ function ToolRow({ tool }: { tool: ToolItem }) {
     tool.status === "error" || !!tool.diff || !!tool.hasDiff
   );
   return (
-    <div>
+    <div data-item={tool.id}>
       <button
         type="button"
         onClick={() => setOpen(!open)}

package/components/Chat/find-highlight.test.ts

@@ -0,0 +1,56 @@
+import { JSDOM } from "jsdom";
+import { describe, expect, it, vi } from "vitest";
+import { findRanges, matchSpans } from "./find-highlight";
+import { RowStore } from "./rowState";
+
+// The suite's setup needs node, so the DOM is built here.
+const { window } = new JSDOM("<!doctype html><body></body>");
+const { document } = window;
+
+describe("matchSpans", () => {
+  it("finds a match split across pieces", () => {
+    expect(matchSpans(["const ", "fo", "o = 1"], "foo =")).toEqual([
+      { start: [1, 0], end: [2, 3] },
+    ]);
+  });
+
+  it("ends a match at the close of its piece, not the start of the next", () => {
+    expect(matchSpans(["ab", "cd"], "ab")).toEqual([
+      { start: [0, 0], end: [0, 2] },
+    ]);
+  });
+});
+
+describe("findRanges", () => {
+  it("covers markdown and a highlighted code block without touching them", () => {
+    document.body.innerHTML = `
+      <div id="root">
+        <p>Run <strong>npm</strong> test, then <code>npm run lint</code></p>
+        <pre><span class="k">npm</span><span> </span><span>ci</span></pre>
+      </div>`;
+    const root = document.getElementById("root")!;
+    const before = root.innerHTML;
+    const ranges = findRanges(root, "NPM");
+    expect(ranges.map((r) => r.toString())).toEqual(["npm", "npm", "npm"]);
+    expect(findRanges(root, "npm ci").map((r) => r.toString())).toEqual([
+      "npm ci",
+    ]);
+    expect(root.innerHTML).toBe(before);
+  });
+});
+
+describe("RowStore", () => {
+  it("tells an open row when find opens it from outside", () => {
+    const rows = new RowStore();
+    const heard = vi.fn();
+    const stop = rows.subscribe("steps:t1", heard);
+    rows.set("steps:t1", true);
+    rows.set("steps:t1", true);
+    rows.set("tool:t2", true);
+    expect(heard).toHaveBeenCalledTimes(1);
+    expect(rows.get("steps:t1")).toBe(true);
+    stop();
+    rows.set("steps:t1", false);
+    expect(heard).toHaveBeenCalledTimes(1);
+  });
+});

package/components/Chat/find-highlight.ts

@@ -0,0 +1,78 @@
+/**
+ * Marks find's matches in the rendered conversation with the CSS Custom
+ * Highlight API: ranges painted over the text, so markdown, code blocks and
+ * React's own DOM are never rewritten. Browsers without it still scroll to
+ * the match; they just don't paint it.
+ */
+
+import { occurrences } from "@/lib/chat/find";
+
+// Where a match starts and ends, as [piece, offset] in a run of text pieces.
+export interface Span {
+  start: [number, number];
+  end: [number, number];
+}
+
+// Matches across text split over several nodes (a highlighted code line is
+// many spans), found as if the pieces were one string.
+export function matchSpans(pieces: string[], query: string): Span[] {
+  const starts: number[] = [];
+  let text = "";
+  for (const p of pieces) {
+    starts.push(text.length);
+    text += p;
+  }
+  // The piece holding position `i`; an end prefers the piece it closes.
+  const at = (i: number, end: boolean): [number, number] => {
+    let k = 0;
+    for (let j = 0; j < pieces.length; j++) {
+      if (starts[j] > i || (end && starts[j] === i && j > 0)) break;
+      k = j;
+    }
+    return [k, i - starts[k]];
+  };
+  return occurrences(text, query).map((i) => ({
+    start: at(i, false),
+    end: at(i + query.length, true),
+  }));
+}
+
+// The ranges `query` covers in `root`'s text.
+export function findRanges(root: Node, query: string): Range[] {
+  const doc = root.ownerDocument ?? (root as Document);
+  const walker = doc.createTreeWalker(root, 4 /* NodeFilter.SHOW_TEXT */);
+  const nodes: Text[] = [];
+  for (let n = walker.nextNode(); n; n = walker.nextNode())
+    if (n.nodeValue) nodes.push(n as Text);
+  return matchSpans(
+    nodes.map((n) => n.nodeValue ?? ""),
+    query
+  ).map(({ start, end }) => {
+    const r = doc.createRange();
+    r.setStart(nodes[start[0]], start[1]);
+    r.setEnd(nodes[end[0]], end[1]);
+    return r;
+  });
+}
+
+// Every open find bar's marks, painted together: there's one registry.
+const painted = new Map<object, { all: Range[]; current: Range | null }>();
+
+function repaint() {
+  if (typeof CSS === "undefined" || !("highlights" in CSS)) return;
+  const all = [...painted.values()];
+  CSS.highlights.set("chat-find", new Highlight(...all.flatMap((p) => p.all)));
+  CSS.highlights.set(
+    "chat-find-current",
+    new Highlight(...all.flatMap((p) => (p.current ? [p.current] : [])))
+  );
+}
+
+export function paint(owner: object, all: Range[], current: Range | null) {
+  painted.set(owner, { all, current });
+  repaint();
+}
+
+export function unpaint(owner: object) {
+  if (painted.delete(owner)) repaint();
+}