@saadnvd1/agent-os 0.3.553 → 0.3.556

package/app/api/sessions/[id]/done/route.test.ts

@@ -0,0 +1,70 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const doneSession = vi.hoisted(() => vi.fn());
+const deadline = vi.hoisted(() => vi.fn());
+vi.mock("@/lib/done", () => ({
+  doneSession,
+  getDoneTarget: (id: string) => {
+    if (id === "gone") throw new Error("Session not found");
+    return { id, name: "Fix pair page menu label" };
+  },
+}));
+vi.mock("@/lib/done/deadline", () => ({
+  withinDeadline: (...a: unknown[]) => {
+    deadline(...a);
+    return a[0];
+  },
+}));
+
+const { POST } = await import("./route");
+const post = (id: string) =>
+  POST(new Request("http://x", { method: "POST" }), {
+    params: Promise.resolve({ id }),
+  });
+
+const unhandled: unknown[] = [];
+process.on("unhandledRejection", (e) => unhandled.push(e));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  unhandled.length = 0;
+});
+
+describe("POST /api/sessions/:id/done", () => {
+  it("answers 404 for an unknown id, without starting anything or leaving a rejection", async () => {
+    const res = await post("gone");
+    expect(res.status).toBe(404);
+    expect(doneSession).not.toHaveBeenCalled();
+    await new Promise((r) => setTimeout(r, 10));
+    expect(unhandled).toEqual([]);
+  });
+
+  it("runs a quick change's done through the deadline wrapper", async () => {
+    doneSession.mockResolvedValue({ text: "Merged." });
+    const res = await post("q1");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ outcome: { text: "Merged." } });
+    expect(deadline).toHaveBeenCalledWith(
+      expect.any(Promise),
+      "Fix pair page menu label"
+    );
+  });
+
+  it("returns the refusal, and a second done while one runs is refused", async () => {
+    let finish!: (v: unknown) => void;
+    doneSession.mockReturnValueOnce(new Promise((r) => (finish = r)));
+    const first = post("q2");
+    await new Promise((r) => setTimeout(r, 0));
+    const second = await post("q2");
+    expect(second.status).toBe(409);
+    expect((await second.json()).error).toMatch(/already being finished/);
+    expect(doneSession).toHaveBeenCalledTimes(1);
+    finish({ text: "ok" });
+    expect((await first).status).toBe(200);
+
+    doneSession.mockRejectedValueOnce(new Error("Not done. ci failed"));
+    const refused = await post("q2");
+    expect(refused.status).toBe(409);
+    expect((await refused.json()).error).toMatch(/ci failed/);
+  });
+});

package/app/api/sessions/[id]/done/route.ts

@@ -1,19 +1,45 @@
 import { NextResponse } from "next/server";
-import { doneSession } from "@/lib/done";
+import { doneSession, getDoneTarget } from "@/lib/done";
+import { withinDeadline } from "@/lib/done/deadline";
+
+// Sessions with a done running. Released when the work ends, not when the
+// request's deadline does, so a retry can't start a parallel run beside one
+// that is still going.
+const g = globalThis as unknown as { __agentosDoneRunning?: Set<string> };
+const running: Set<string> = (g.__agentosDoneRunning ??= new Set());
 
 // POST /api/sessions/:id/done - finished work: merge through the gates if
-// its PR is open, clean up, archive. 409 with the reason when refused.
+// its PR is open, clean up, archive. 404 for an unknown session, 409 with
+// the reason when refused or already running.
 export async function POST(
   _request: Request,
   { params }: { params: Promise<{ id: string }> }
 ) {
+  const id = (await params).id;
+  let name: string;
+  try {
+    name = getDoneTarget(id).name;
+  } catch {
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  }
+  if (running.has(id))
+    return NextResponse.json(
+      { error: `${name} is already being finished: wait for it to end.` },
+      { status: 409 }
+    );
+  running.add(id);
   try {
-    const outcome = await doneSession((await params).id, {
-      by: "direct",
-      onPeer: true,
-    });
+    const work = doneSession(id, { by: "direct", onPeer: true });
+    work.then(
+      () => running.delete(id),
+      () => running.delete(id)
+    );
+    const outcome = await withinDeadline(work, name);
     return NextResponse.json({ outcome });
   } catch (error) {
+    // A done that threw before it started has nothing left to hold.
+    if (!(error instanceof Error) || !/taking longer/.test(error.message))
+      running.delete(id);
     const message = error instanceof Error ? error.message : String(error);
     return NextResponse.json({ error: message }, { status: 409 });
   }

package/app/api/updates/check/route.ts

@@ -0,0 +1,17 @@
+import { NextRequest, NextResponse } from "next/server";
+import { approverOf } from "@/lib/security/approver";
+import { checkForUpdate } from "@/lib/updates/check";
+import { updateView } from "@/lib/updates/view";
+
+// POST /api/updates/check - look now, at most once a minute.
+export async function POST(request: NextRequest) {
+  const { throttled } = await checkForUpdate({ force: true });
+  if (throttled)
+    return NextResponse.json(
+      { error: "Checked a moment ago.", retryAfter: throttled },
+      { status: 429, headers: { "Retry-After": String(throttled) } }
+    );
+  return NextResponse.json(
+    await updateView({ mayUpdate: !!approverOf(request.headers) })
+  );
+}

package/app/api/updates/route.test.ts

@@ -0,0 +1,205 @@
+import fs from "fs";
+import path from "path";
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { db } from "@/lib/db";
+import { DEVICE_HEADER, TRUST_HEADER } from "@/lib/security/auth";
+import { mintDevice, setDeviceCanApprove } from "@/lib/security/devices";
+import type { CheckResult } from "@/lib/updates/check";
+
+let check: CheckResult | null;
+let throttled: number | undefined;
+let refreshed: CheckResult | null = null;
+vi.mock("@/lib/updates/check", async (orig) => ({
+  ...(await orig<typeof import("@/lib/updates/check")>()),
+  cachedCheck: () => check,
+  checkForUpdate: async () => ({ result: refreshed ?? check, throttled }),
+}));
+vi.mock("@/lib/busy", () => ({ inFlight: () => ({ reviews: 0, setups: 0 }) }));
+vi.mock("@/lib/status/collect", () => ({
+  collectStatuses: async () => ({
+    statuses: {
+      a: { status: "running" },
+      b: { status: "running" },
+      c: { status: "idle" },
+    },
+  }),
+}));
+
+const root = await import("./route");
+const runRoute = await import("./run/route");
+const checkRoute = await import("./check/route");
+const settingsRoute = await import("./settings/route");
+
+const req = (
+  path: string,
+  method: string,
+  headers: Record<string, string>,
+  body?: unknown
+) =>
+  new NextRequest(`http://localhost/api/updates${path}`, {
+    method,
+    headers: {
+      ...headers,
+      ...(body !== undefined && { "content-type": "application/json" }),
+    },
+    ...(body !== undefined && { body: JSON.stringify(body) }),
+  });
+
+const loopback = { [TRUST_HEADER]: "loopback" };
+const available = (): CheckResult => ({
+  status: "ok",
+  current: { version: "0.3.1", sha: "a" },
+  latest: { version: "0.3.5", sha: "b", notes: ["x"], url: null },
+  behind: 4,
+  available: true,
+  branch: "main",
+  checkedAt: 1,
+  error: null,
+});
+
+beforeEach(() => {
+  check = available();
+  throttled = undefined;
+  refreshed = null;
+  delete process.env.AGENTOS_UPDATE_BANNER;
+  process.env.AGENTOS_DEV = "1";
+  db.prepare(`DELETE FROM settings WHERE key LIKE 'updates.%'`).run();
+});
+
+describe("GET /api/updates", () => {
+  it("describes the update, and says who may start it", async () => {
+    const view = await (await root.GET(req("", "GET", loopback))).json();
+    expect(view).toMatchObject({
+      available: true,
+      current: { version: "0.3.1" },
+      latest: { version: "0.3.5" },
+      bannerEnabled: true,
+      working: { sessions: 2 },
+    });
+    // A dev server refuses, with the reason.
+    expect(view.canUpdate).toMatchObject({ ok: false, code: "dev" });
+  });
+
+  it("a device without Can approve can read it but not update", async () => {
+    const { device } = mintDevice("phone");
+    setDeviceCanApprove(device.id, false);
+    const headers = { [TRUST_HEADER]: "device", [DEVICE_HEADER]: device.id };
+    const view = await (await root.GET(req("", "GET", headers))).json();
+    expect(view.canUpdate).toMatchObject({ ok: false, code: "forbidden" });
+    const res = await runRoute.POST(
+      req("/run", "POST", headers, { when: "now" })
+    );
+    expect(res.status).toBe(403);
+  });
+});
+
+describe("after an update", () => {
+  it("asks again instead of offering the version that was just installed", async () => {
+    const file = path.join(
+      path.dirname(process.env.DB_PATH!),
+      "agent-os-update.json"
+    );
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        id: "r",
+        phase: "done",
+        from: "a",
+        fromVersion: "0.3.1",
+        toVersion: "0.3.5",
+        startedAt: 5,
+        finishedAt: 10,
+      })
+    );
+    refreshed = { ...available(), available: false, behind: 0, checkedAt: 20 };
+    try {
+      const view = await (await root.GET(req("", "GET", loopback))).json();
+      expect(view.available).toBe(false);
+      expect(view.run.phase).toBe("done");
+    } finally {
+      fs.rmSync(file, { force: true });
+    }
+  });
+});
+
+describe("POST /api/updates/run", () => {
+  it("rejects a body that isn't now or idle", async () => {
+    for (const body of [{}, { when: "later" }, { when: 1 }])
+      expect(
+        (await runRoute.POST(req("/run", "POST", loopback, body))).status
+      ).toBe(400);
+  });
+
+  it("answers 409 with the code when the update can't run", async () => {
+    const res = await runRoute.POST(
+      req("/run", "POST", loopback, { when: "now" })
+    );
+    expect(res.status).toBe(409);
+    expect(await res.json()).toMatchObject({ code: "dev" });
+    expect(
+      db.prepare(`SELECT 1 FROM settings WHERE key = 'updates.pending'`).get()
+    ).toBeUndefined();
+  });
+
+  it("refuses an anonymous caller", async () => {
+    expect(
+      (await runRoute.POST(req("/run", "POST", {}, { when: "now" }))).status
+    ).toBe(403);
+    expect((await runRoute.DELETE(req("/run", "DELETE", {}))).status).toBe(403);
+  });
+
+  it("cancels a requested update", async () => {
+    db.prepare(
+      `INSERT INTO settings (key, value) VALUES ('updates.pending', ?)`
+    ).run(JSON.stringify({ requestedAt: Date.now() }));
+    const view = await (
+      await runRoute.DELETE(req("/run", "DELETE", loopback))
+    ).json();
+    expect(view.pending).toBeNull();
+  });
+});
+
+describe("POST /api/updates/check", () => {
+  it("answers 429 inside the floor", async () => {
+    throttled = 40;
+    const res = await checkRoute.POST(req("/check", "POST", loopback));
+    expect(res.status).toBe(429);
+    expect(res.headers.get("Retry-After")).toBe("40");
+  });
+});
+
+describe("PUT /api/updates/settings", () => {
+  it("turns the banner off and back on", async () => {
+    let view = await (
+      await settingsRoute.PUT(
+        req("/settings", "PUT", loopback, { banner: false })
+      )
+    ).json();
+    expect(view.bannerEnabled).toBe(false);
+    view = await (
+      await settingsRoute.PUT(
+        req("/settings", "PUT", loopback, { banner: true })
+      )
+    ).json();
+    expect(view.bannerEnabled).toBe(true);
+  });
+
+  it("is refused when pinned by the environment, and for a bad body", async () => {
+    expect(
+      (
+        await settingsRoute.PUT(
+          req("/settings", "PUT", loopback, { banner: "no" })
+        )
+      ).status
+    ).toBe(400);
+    process.env.AGENTOS_UPDATE_BANNER = "off";
+    expect(
+      (
+        await settingsRoute.PUT(
+          req("/settings", "PUT", loopback, { banner: true })
+        )
+      ).status
+    ).toBe(409);
+  });
+});

package/app/api/updates/route.ts

@@ -0,0 +1,11 @@
+import { NextRequest, NextResponse } from "next/server";
+import { approverOf } from "@/lib/security/approver";
+import { updateView } from "@/lib/updates/view";
+
+// GET /api/updates - the installed version, the latest one, the update run
+// in progress and whether the caller may start one.
+export async function GET(request: NextRequest) {
+  return NextResponse.json(
+    await updateView({ mayUpdate: !!approverOf(request.headers) })
+  );
+}

package/app/api/updates/run/route.ts

@@ -0,0 +1,50 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import {
+  cancelPending,
+  readRun,
+  realRunDeps,
+  startUpdate,
+} from "@/lib/updates/run";
+import { isActivePhase } from "@/lib/updates/banner";
+import { updateView } from "@/lib/updates/view";
+
+// POST /api/updates/run {when: "now" | "idle"} - start an update, or ask for
+// one once nothing is working. Nothing updates unless this is called.
+export async function POST(request: NextRequest) {
+  const allowed = requireApprover(request);
+  if (!allowed.ok) return allowed.response;
+  const body = (await request.json().catch(() => null)) as {
+    when?: unknown;
+  } | null;
+  if (body?.when !== "now" && body?.when !== "idle")
+    return NextResponse.json(
+      { error: 'when must be "now" or "idle".' },
+      { status: 400 }
+    );
+  const started = await startUpdate({ when: body.when });
+  if (!started.ok)
+    return NextResponse.json(
+      { code: started.code, error: started.error },
+      { status: 409 }
+    );
+  return NextResponse.json(await updateView({ mayUpdate: true }), {
+    status: 202,
+  });
+}
+
+// DELETE /api/updates/run - cancel a requested "update when idle". A started
+// update can't be stopped.
+export async function DELETE(request: NextRequest) {
+  const allowed = requireApprover(request);
+  if (!allowed.ok) return allowed.response;
+  const deps = realRunDeps();
+  const run = readRun(deps);
+  if (run && isActivePhase(run.phase))
+    return NextResponse.json(
+      { error: "The update has started and can't be stopped." },
+      { status: 409 }
+    );
+  cancelPending(deps);
+  return NextResponse.json(await updateView({ mayUpdate: true }));
+}

package/app/api/updates/settings/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { requireApprover } from "@/lib/security/approver";
+import { bannerLocked, setBannerEnabled } from "@/lib/updates/settings";
+import { updateView } from "@/lib/updates/view";
+
+// PUT /api/updates/settings {banner: boolean} - show the update banner or not.
+export async function PUT(request: NextRequest) {
+  const allowed = requireApprover(request);
+  if (!allowed.ok) return allowed.response;
+  const body = (await request.json().catch(() => null)) as {
+    banner?: unknown;
+  } | null;
+  if (typeof body?.banner !== "boolean")
+    return NextResponse.json(
+      { error: "banner must be true or false." },
+      { status: 400 }
+    );
+  if (bannerLocked())
+    return NextResponse.json(
+      { error: "The banner is pinned off by AGENTOS_UPDATE_BANNER." },
+      { status: 409 }
+    );
+  setBannerEnabled(body.banner);
+  return NextResponse.json(await updateView({ mayUpdate: true }));
+}

package/components/Chat/ChatPanel.tsx

@@ -27,7 +27,7 @@ import {
   OVERLAY_SELECTOR,
 } from "@/lib/chat/escape";
 import { sentPrompts } from "@/lib/chat/history";
-import { quoteMarkdown } from "@/lib/chat/quote";
+import { quoteInsert, quoteMarkdown } from "@/lib/chat/quote";
 import { OrchestratorBar } from "@/components/Orchestrator/OrchestratorBar";
 import { ActivityLine } from "./Activity";
 import { Approval } from "./Approval";
@@ -82,6 +82,7 @@ interface ItemActions {
   onKeepPlanning?: () => void;
   // Absent while the agent is working, and inside undone messages.
   onUndo?: (id: string) => void;
+  onQuote?: (text: string) => void;
 }
 
 function Item({ item, actions }: { item: ChatItem; actions: ItemActions }) {
@@ -98,7 +99,7 @@ function Item({ item, actions }: { item: ChatItem; actions: ItemActions }) {
         />
       );
     case "assistant":
-      return <AssistantMessage item={item} />;
+      return <AssistantMessage item={item} onQuote={actions.onQuote} />;
     case "reasoning":
       return <Reasoning item={item} />;
     case "todos":
@@ -171,7 +172,10 @@ const Block = memo(
     actions: ItemActions;
   }) {
     const respond = actions.respond;
-    const undoneActions = useMemo(() => ({ respond }), [respond]);
+    const undoneActions = useMemo(
+      () => ({ respond, onQuote: actions.onQuote }),
+      [respond, actions.onQuote]
+    );
     return b.type === "tools" ? (
       <ToolGroup tools={b.tools} />
     ) : b.type === "events" ? (
@@ -239,7 +243,11 @@ export function ChatPanel({
   // The tab on show in the focused pane: opening it takes the caret.
   active: boolean;
 }) {
-  const [prefill, setPrefill] = useState<{ text: string; at: number }>();
+  const [prefill, setPrefill] = useState<{
+    text: string;
+    at: number;
+    append?: boolean;
+  }>();
   const {
     items,
     hasMore,
@@ -305,7 +313,11 @@ export function ChatPanel({
   const shownSuggestion = suggestion === dismissed ? null : suggestion;
   const dismissSuggestion = useCallback((s: string) => setDismissed(s), []);
   const history = useMemo(() => sentPrompts(items), [items]);
-  const [insert, setInsert] = useState<{ text: string; at: number }>();
+  const [insert, setInsert] = useState<{
+    text: string;
+    at: number;
+    append?: boolean;
+  }>();
 
   // Esc sets the composer's ghost text aside, or else stops the turn
   // (lib/chat/escape), from anywhere in this panel.
@@ -555,6 +567,7 @@ export function ChatPanel({
       onUndo: idle ? (id) => undo(id, true) : undefined,
       onCarryPlan: idle ? carryPlan : undefined,
       onKeepPlanning: focusComposer,
+      onQuote: (text) => setInsert(quoteInsert(text)),
     }),
     [respond, idle, undo, carryPlan, focusComposer]
   );

package/components/Chat/Messages.test.ts

@@ -0,0 +1,44 @@
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it, vi } from "vitest";
+import { AssistantMessage } from "./Messages";
+
+const item = {
+  id: "a1",
+  kind: "assistant",
+  text: "Hello\n\n```ts\nx\n```",
+  streaming: false,
+} as never;
+
+describe("AssistantMessage quote action", () => {
+  it("shows a labelled Quote button next to Copy", () => {
+    const html = renderToStaticMarkup(
+      createElement(AssistantMessage, { item, onQuote: vi.fn() })
+    );
+    expect(html).toContain('aria-label="Copy message"');
+    expect(html).toContain('aria-label="Quote message"');
+    expect(html).toContain('title="Quote"');
+  });
+
+  it("hands the markdown source to onQuote on click", () => {
+    const onQuote = vi.fn();
+    const el = AssistantMessage({ item, onQuote }) as never as {
+      props: { children: unknown[] };
+    };
+    const group = (
+      el.props.children as { props: { children: unknown[] } }[]
+    )[1];
+    const button = group.props.children[1] as {
+      props: { onClick: () => void };
+    };
+    button.props.onClick();
+    expect(onQuote).toHaveBeenCalledWith("Hello\n\n```ts\nx\n```");
+  });
+
+  it("has no Quote button without a handler", () => {
+    const html = renderToStaticMarkup(
+      createElement(AssistantMessage, { item })
+    );
+    expect(html).not.toContain("Quote message");
+  });
+});

package/components/Chat/Messages.tsx

@@ -1,6 +1,13 @@
 "use client";
 
-import { Check, ChevronRight, Circle, CircleDot, Sparkles } from "lucide-react";
+import {
+  Check,
+  ChevronRight,
+  Circle,
+  CircleDot,
+  Quote,
+  Sparkles,
+} from "lucide-react";
 import type { ChatItem } from "@/lib/chat/events";
 import { cn } from "@/lib/utils";
 import { leadingCommand } from "@/lib/chat/commands";
@@ -91,18 +98,33 @@ export function UserMessage({
   );
 }
 
-export function AssistantMessage({ item }: { item: Of<"assistant"> }) {
+export function AssistantMessage({
+  item,
+  onQuote,
+}: {
+  item: Of<"assistant">;
+  onQuote?: (text: string) => void;
+}) {
   return (
     <div className="group">
       <div data-quotable className={cn(item.streaming && "streaming-cursor")}>
         <Markdown text={item.text} streaming={item.streaming} />
       </div>
       {!item.streaming && (
-        <CopyButton
-          text={item.text}
-          label="Copy message"
-          className="-ml-1.5 opacity-40 group-hover:opacity-100 md:opacity-0"
-        />
+        <div className="-ml-1.5 flex items-center opacity-40 group-hover:opacity-100 md:opacity-0">
+          <CopyButton text={item.text} label="Copy message" />
+          {onQuote && (
+            <button
+              type="button"
+              aria-label="Quote message"
+              title="Quote"
+              onClick={() => onQuote(item.text)}
+              className="text-muted-foreground hover:text-foreground hover:bg-foreground/[0.06] flex h-9 w-9 items-center justify-center rounded-md md:h-7 md:w-7"
+            >
+              <Quote className="h-3.5 w-3.5" />
+            </button>
+          )}
+        </div>
       )}
     </div>
   );

package/components/Chat/composer/ComposerBody.tsx

@@ -22,6 +22,7 @@ import { ComposerMenu, type MenuOption } from "../ComposerMenu";
 import { offeredSuggestion } from "@/lib/chat/suggestion";
 import { historyStep } from "@/lib/chat/history";
 import { markdownParagraphs } from "@/lib/chat/quote";
+import { insertMarkdown } from "./insert";
 import { useCoarsePointer } from "./useCoarsePointer";
 import { useMentions } from "./useMentions";
 import { Attachments } from "./Attachments";
@@ -68,7 +69,9 @@ export interface ComposerProps {
   // Files and folders for an @mention.
   requestFiles?: (query: string) => Promise<FileSuggestion[]>;
   // Markdown to put in at the caret (a quote), once per `at`.
-  insert?: { text: string; at: number };
+  // `append` puts it after what's already written, on its own lines, rather
+  // than at the caret.
+  insert?: { text: string; at: number; append?: boolean };
   // Takes the caret once it's ready, and again each time this changes to a
   // new key (the conversation shown), unless the user is busy elsewhere.
   focusKey?: string | null;
@@ -155,7 +158,7 @@ export function ComposerBody({
     inserted.current = insert.at;
     const content = markdownParagraphs(insert.text);
     if (!content.length) return;
-    editor.chain().focus().insertContent(content).run();
+    insertMarkdown(editor, content, insert.append);
   }, [insert, editor]);
 
   const query = slashQuery(text);

package/components/Chat/composer/hook.test.ts

@@ -6,6 +6,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { Editor } from "@tiptap/core";
 import * as extensions from "./extensions";
 import * as serialize from "@/lib/chat/markdown/serialize";
+import { insertMarkdown } from "./insert";
+import { quoteInsert, markdownParagraphs } from "@/lib/chat/quote";
 import { useComposerEditor, type ComposerHandlers } from "./useComposerEditor";
 
 vi.mock("./extensions", async (original) => {
@@ -95,4 +97,26 @@ describe("useComposerEditor", () => {
     });
     expect(last.text).toBe("hi");
   });
+
+  it("quotes under an existing draft, caret after the quote", async () => {
+    await render();
+    await act(async () => last.setText("my draft"));
+    const q = quoteInsert("one\ntwo");
+    await act(async () =>
+      insertMarkdown(editor(), markdownParagraphs(q.text), q.append)
+    );
+    expect(last.text).toBe("my draft\n> one\n> two\n\n");
+    expect(editor().state.selection.from).toBe(
+      editor().state.doc.content.size - 1
+    );
+  });
+
+  it("quotes into an empty composer", async () => {
+    await render();
+    const q = quoteInsert("hi");
+    await act(async () =>
+      insertMarkdown(editor(), markdownParagraphs(q.text), q.append)
+    );
+    expect(last.text.startsWith("> hi")).toBe(true);
+  });
 });