@agent-native/core-corpus 0.210.2 → 0.211.0

package/corpus/templates/content/app/components/editor/live-editor-session.ts

@@ -1,9 +1,12 @@
 import { createContext, useContext, useEffect } from "react";
 
+import { holdPageDraftWriter } from "./page-draft-journal";
+
 /**
  * Lets the mounted editor tell PageDraftRecovery which editor session is live.
  * A recovery draft written by that session belongs to the editor's own save
- * queue, so recovery must not replace the editor while it settles.
+ * queue, so recovery must not replace the editor while it settles. Other tabs
+ * learn the session is live through its writer lock.
  */
 export const LiveEditorSessionContext = createContext<
   ((editorSessionId: string | null) => void) | null
@@ -16,4 +19,5 @@ export function useRegisterLiveEditorSession(editorSessionId: string): void {
     register(editorSessionId);
     return () => register(null);
   }, [editorSessionId, register]);
+  useEffect(() => holdPageDraftWriter(editorSessionId), [editorSessionId]);
 }

package/corpus/templates/content/app/components/editor/page-draft-journal.ts

@@ -52,6 +52,63 @@ export class PageDraftJournalError extends Error {
 const PREFIX = "content-page-draft-journal-v1:";
 // Retired: these markers kept a permanent "saved to History" banner on screen.
 const LEGACY_RETAINED_PREFIX = "content-page-draft-retained-v1:";
+const WRITER_LOCK_PREFIX = "content-page-draft-writer-v1:";
+
+function lockManager(): LockManager | null {
+  return typeof navigator === "undefined" ? null : (navigator.locks ?? null);
+}
+
+/**
+ * Holds a Web Lock named for this editor session until the returned release
+ * runs. Every tab shares the journal, so the lock is how another tab tells an
+ * entry whose editor is still open from one a closed or reloaded tab left
+ * behind; the browser drops it with the tab.
+ */
+export function holdPageDraftWriter(writerId: string): () => void {
+  const locks = lockManager();
+  if (!locks) return () => {};
+  let released = false;
+  let release: (() => void) | null = null;
+  locks
+    .request(
+      WRITER_LOCK_PREFIX + writerId,
+      () =>
+        new Promise<void>((resolve) => {
+          if (released) resolve();
+          else release = resolve;
+        }),
+    )
+    .catch((error: unknown) => {
+      // coercion-ok: A writer whose lock was refused reads as gone, so another
+      // tab may replay its journal, as it did before writer locks. Reading it
+      // as live instead would strand that journal once this tab closed.
+      console.warn(
+        "Could not hold the page draft writer lock; another tab may replay this editor's draft",
+        error,
+      );
+    });
+  return () => {
+    released = true;
+    release?.();
+  };
+}
+
+/**
+ * The writer IDs whose editors are open in some tab, or null when this
+ * browser has no Web Locks and cannot tell.
+ */
+export async function liveDraftWriterIds(): Promise<ReadonlySet<string> | null> {
+  const locks = lockManager();
+  if (!locks) return null;
+  const { held = [] } = await locks.query();
+  return new Set(
+    held.flatMap(({ name }) =>
+      name?.startsWith(WRITER_LOCK_PREFIX)
+        ? [name.slice(WRITER_LOCK_PREFIX.length)]
+        : [],
+    ),
+  );
+}
 
 function storage(): Storage {
   try {
@@ -337,10 +394,13 @@ export function listPageDraftJournal(
 
 export function readPageDraftJournal(
   scope: Omit<PageDraftJournalScope, "writerId">,
+  skipWriterIds: ReadonlySet<string> = new Set(),
 ): PageDraftJournalEntry | null {
   return (
     listPageDraftJournal(scope).find(
-      (entry) => entry.recoveryStatus !== "retained_in_history",
+      (entry) =>
+        entry.recoveryStatus !== "retained_in_history" &&
+        !skipWriterIds.has(entry.scope.writerId),
     ) ?? null
   );
 }

package/corpus/templates/content/app/components/editor/property-comments.tsx

@@ -12,6 +12,11 @@ import {
 import type { CommentThread } from "@/hooks/use-comments";
 import { cn } from "@/lib/utils";
 
+import {
+  formatPropertyDate,
+  formatPropertyDateTime,
+} from "./property-date-format";
+
 /**
  * What a Page editor tells its Properties about their Comment threads, and how
  * a Property starts or opens one. Without a provider, Properties show no
@@ -60,9 +65,10 @@ export function bodyCommentThreads(
 export interface PropertyThreadTarget {
   name: string;
   /**
-   * The value when the thread started. Threads that recorded none (one
-   * still being saved, or a relation, rollup, or formula) show the value
-   * now, and nothing once the Property is gone.
+   * The value when the thread started, with dates read as the table shows
+   * them. Threads that recorded none (one still being saved, or a relation,
+   * rollup, or formula) show the value now, and nothing once the Property is
+   * gone.
    */
   value: string | null;
   /**
@@ -73,6 +79,29 @@ export interface PropertyThreadTarget {
   state: "current" | "changed" | "removed" | "unknown";
 }
 
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+
+/** ISO text as Properties show dates; anything else as it was written. */
+function readableDate(text: string) {
+  if (ISO_DATE.test(text)) return formatPropertyDate(text);
+  if (ISO_DATE_TIME.test(text)) return formatPropertyDateTime(text);
+  return text;
+}
+
+/**
+ * A remembered value as its Property shows values. Comments remember dates
+ * as ISO text, and a range as "start - end". A value recorded before the
+ * Property became a date keeps its text.
+ */
+function readablePropertyValue(value: string, type: string | undefined) {
+  if (type === "date") return value.split(" - ").map(readableDate).join(" - ");
+  if (type === "created_time" || type === "last_edited_time") {
+    return readableDate(value);
+  }
+  return value;
+}
+
 export function propertyThreadTarget(
   property: NonNullable<CommentThread["property"]>,
   properties: readonly DocumentProperty[] | undefined,
@@ -84,7 +113,9 @@ export function propertyThreadTarget(
   const value = property.propertyValue ?? currentValue;
   return {
     name: property.propertyName ?? current?.definition.name ?? "",
-    value,
+    value: value
+      ? readablePropertyValue(value, current?.definition.type)
+      : value,
     state: !properties
       ? "unknown"
       : !current

package/corpus/templates/content/app/components/editor/property-date-format.ts

@@ -0,0 +1,45 @@
+/** A date as Properties show it, such as "Nov 2, 2026". */
+export function formatPropertyDate(value: string) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    const [year, month, day] = value.split("-").map(Number);
+    return new Intl.DateTimeFormat(undefined, {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+    }).format(new Date(year, month - 1, day));
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return new Intl.DateTimeFormat(undefined, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  }).format(date);
+}
+
+/** A date and time as Properties show it, such as "Nov 2, 2026, 3:30 PM". */
+export function formatPropertyDateTime(value: string) {
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value)) {
+    const [datePart, timePart] = value.split("T");
+    const [year, month, day] = datePart.split("-").map(Number);
+    const [hour, minute] = timePart.split(":").map(Number);
+    return new Intl.DateTimeFormat(undefined, {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+    }).format(new Date(year, month - 1, day, hour, minute));
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return new Intl.DateTimeFormat(undefined, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  }).format(date);
+}

package/corpus/templates/content/app/components/editor/thread-suggestions.ts

@@ -57,6 +57,36 @@ export function suggestionsByThread(
   return grouped;
 }
 
+function anchorStart(suggestion: ResourceSuggestion): number {
+  const from = (suggestion.operations[0]?.anchor as { from?: unknown } | null)
+    ?.from;
+  return typeof from === "number" ? from : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * The edits reviewed together in a thread: every edit of one proposal in a
+ * group, in Page order, and any other suggestion alone. Groups keep the order
+ * of their first edit.
+ */
+export function proposalGroups(
+  suggestions: readonly ResourceSuggestion[],
+): ResourceSuggestion[][] {
+  const groups = new Map<string, ResourceSuggestion[]>();
+  for (const suggestion of suggestions) {
+    const key = suggestion.proposalId
+      ? `proposal:${suggestion.proposalId}`
+      : suggestion.id;
+    groups.set(key, [...(groups.get(key) ?? []), suggestion]);
+  }
+  return [...groups.values()].map((group) =>
+    group.length > 1
+      ? [...group].sort(
+          (left, right) => anchorStart(left) - anchorStart(right) || 0,
+        )
+      : group,
+  );
+}
+
 // Suggestion ids are URL-safe, so the encoded id in the link is the id itself.
 // The receipt's summary has its brackets stripped, so it is the whole comment.
 const RECEIPT_LINK = /^\[[^[\]]*\]\([^)\s]*[?&]suggestion=([\w.~-]+)[^)\s]*\)$/;

package/corpus/templates/content/app/components/editor/useDocumentReconcileRecovery.ts

@@ -25,6 +25,24 @@ export interface ReconcileRecoveryDraft {
   localTitle: string;
 }
 
+// After typing overtakes an automatic save, the next one waits for a pause,
+// as the editor's autosave does, but never longer than the cap.
+const AUTOMATIC_SAVE_IDLE_MS = 1_000;
+const AUTOMATIC_SAVE_MAX_WAIT_MS = 5_000;
+
+async function untilTypingPauses(getIdentity: () => string): Promise<void> {
+  const deadline = Date.now() + AUTOMATIC_SAVE_MAX_WAIT_MS;
+  let identity = getIdentity();
+  for (;;) {
+    const wait = Math.min(AUTOMATIC_SAVE_IDLE_MS, deadline - Date.now());
+    if (wait <= 0) return;
+    await new Promise((resolve) => setTimeout(resolve, wait));
+    const next = getIdentity();
+    if (next === identity) return;
+    identity = next;
+  }
+}
+
 interface AutomaticSave {
   generation: number;
   newerBase: ReconcileSaveBase | null;
@@ -190,7 +208,6 @@ export function useDocumentReconcileRecovery({
       const started = run.generation;
       let saveBase: ReconcileSaveBase | undefined = base;
       let draft = initialDraft;
-      let attempts = 0;
       let refused = false;
       try {
         while (generation.current === started && !current.current) {
@@ -201,8 +218,7 @@ export function useDocumentReconcileRecovery({
             draft = latestDraft();
             saveBase = run.newerBase;
             run.newerBase = null;
-            attempts = 0;
-          } else if (refused || attempts === 3) {
+          } else if (refused) {
             await retainLatest();
             // A newer merge can hand its page over while the draft is retained.
             if (run.newerBase) continue;
@@ -211,7 +227,6 @@ export function useDocumentReconcileRecovery({
             }
             return false;
           }
-          attempts += 1;
           const identity = callbacks.current.getSaveIdentity();
           const persisted = await callbacks.current.save(draft, saveBase);
           if (generation.current !== started || current.current) {
@@ -220,7 +235,11 @@ export function useDocumentReconcileRecovery({
           }
           if (persisted && callbacks.current.getSaveIdentity() === identity)
             return true;
+          // A save that landed while typing continued is not a retry: counting
+          // those turns steady typing in another tab into a conflict notice.
           refused = !persisted;
+          if (persisted)
+            await untilTypingPauses(() => callbacks.current.getSaveIdentity());
           draft = latestDraft();
           saveBase = undefined;
         }

package/corpus/templates/content/app/components/sidebar/DocumentSidebar.tsx

@@ -54,6 +54,7 @@ import {
 import {
   clearPageDraftJournal,
   listPageDraftJournal,
+  liveDraftWriterIds,
   PageDraftJournalError,
   readPageDraftJournal,
   writePageDraftJournal,
@@ -253,29 +254,54 @@ export function readCreateRecoveryDraft(
   }
 }
 
+type DraftRead = () =>
+  | PageDraftJournalEntry
+  | null
+  | Promise<PageDraftJournalEntry | null>;
+
 export async function retryCreateAfterDraftRead<T>(
-  read: () => PageDraftJournalEntry | null,
+  read: DraftRead,
   create: () => Promise<T>,
 ): Promise<{ created: T; draft: PageDraftJournalEntry | null }> {
-  const beforeCreate = readCreateRecoveryDraft(read);
-  if (beforeCreate.kind === "unreadable") throw beforeCreate.error;
-
+  // An unreadable journal stops the create before it starts.
+  await read();
   const created = await create();
-  const afterCreate = readCreateRecoveryDraft(read);
-  if (afterCreate.kind === "unreadable") throw afterCreate.error;
-  return { created, draft: afterCreate.entry };
+  return { created, draft: await read() };
 }
 
 export function retryCreateAfterIntentWrite<T>(
   scope: DocumentCreateIntentScope,
   intent: DocumentCreateIntent,
-  read: () => PageDraftJournalEntry | null,
+  read: DraftRead,
   create: () => Promise<T>,
 ): Promise<{ created: T; draft: PageDraftJournalEntry | null }> {
   writeDocumentCreateIntentBestEffort(scope, { ...intent, status: "pending" });
   return retryCreateAfterDraftRead(read, create);
 }
 
+/**
+ * Reads the draft to replay into a page this tab creates for a pending intent.
+ * An editor open in another tab saves its own draft, and replaying that draft
+ * here would race its save, so its entries are skipped. Each read asks again
+ * which editors are open: one can open while the page is being created.
+ */
+export function readReplayableDraft(
+  scope: Parameters<typeof readPageDraftJournal>[0],
+): () => Promise<PageDraftJournalEntry | null> {
+  return async () => {
+    let skipped = await liveDraftWriterIds();
+    for (;;) {
+      const entry = readPageDraftJournal(scope, skipped ?? undefined);
+      if (!entry || !skipped) return entry;
+      // An editor can open and write its first entry between the lock query
+      // and the read, so the entry's writer is checked after reading it.
+      const live = await liveDraftWriterIds();
+      if (!live?.has(entry.scope.writerId)) return entry;
+      skipped = new Set([...skipped, ...live]);
+    }
+  };
+}
+
 export async function readDocumentBeforeCreateDiscard(
   read: () => Promise<Document>,
 ): Promise<{ kind: "committed"; document: Document } | { kind: "missing" }> {
@@ -2224,7 +2250,7 @@ export function DocumentSidebar({
                   showRetry();
                   return;
                 }
-                const read = () => readPageDraftJournal(draftScope);
+                const read = readReplayableDraft(draftScope);
                 const { created, draft } = await retryCreateAfterIntentWrite(
                   scope,
                   currentIntent,
@@ -2308,7 +2334,7 @@ export function DocumentSidebar({
                     clearPageDraftJournal(draft.scope, draft.snapshot);
                   }
                 }
-                const remainingDraft = read();
+                const remainingDraft = await read();
                 confirmedDocument = mergeCreatedDocumentWithDraft(
                   confirmedDocument,
                   remainingDraft,

package/corpus/templates/content/app/global.css

@@ -2458,6 +2458,29 @@ audio.media-block__content {
   background-color: hsl(45 93% 47% / 0.15);
 }
 
+/* A table cell's Comment card. Its thread and composer cards draw their own
+   frame, so the layer only places them. */
+.database-cell-comment-card {
+  z-index: 290;
+  width: 20rem;
+  max-width: calc(100vw - 1.5rem);
+  outline: none;
+  --comment-popover-max-height: min(
+    32rem,
+    calc(var(--radix-popover-content-available-height) - 0.5rem)
+  );
+  max-height: calc(var(--radix-popover-content-available-height) - 0.5rem);
+}
+/* Threads taller than the room scroll rather than run off the screen. Only
+   then, since scrolling clips the cards' shadows. */
+.database-cell-comment-card[data-overflowing] {
+  overflow-y: auto;
+  overscroll-behavior: contain;
+}
+.database-cell-comment-card [data-comments-sidebar] {
+  padding-bottom: 0;
+}
+
 .content-editor .suggestion-settling-original {
   display: none;
 }

package/corpus/templates/content/app/i18n-data.ts

@@ -1557,6 +1557,7 @@ const enUS = {
     openRowComments_few: "{{count}} open comments on {{title}}",
     openRowComments_many: "{{count}} open comments on {{title}}",
     openRowComments_other: "{{count}} open comments on {{title}}",
+    openRow: "Open row",
     reply: "Reply...",
     reopen: "Reopen",
     suggestions: "Suggestions",

package/corpus/templates/content/changelog/2026-10-16-opening-a-page-in-a-new-tab-while-another-tab-is-still-savin.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-16
+---
+
+Opening a page in a new tab while another tab is still saving no longer sends a second save or files a copy to History.

package/corpus/templates/content/changelog/2026-10-16-typing-steadily-in-one-tab-no-longer-makes-another-open-tab-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-16
+---
+
+Typing steadily in one tab no longer makes another open tab show "This page changed elsewhere" after its edits saved.

package/corpus/templates/content/changelog/2026-10-19-database-views-can-filter-the-same-property-more-than-once-n.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-19
+---
+
+Database views can filter one property more than once, number filters add ≥ and ≤, and filter chips name their operator, like "Status: is not done".

package/corpus/templates/content/changelog/2026-10-19-edits-made-from-a-block-s-menu-or-a-table-s-row-and-column-m.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Edits made from a block's menu or a table's row and column menus, such as deleting a table, adding a row or turning off the header row, are now saved instead of coming back after a reload

package/corpus/templates/content/changelog/2026-10-19-starting-a-comment-puts-the-cursor-in-the-comment-box-ready-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Starting a comment puts the cursor in the comment box, ready to type.

package/corpus/templates/content/changelog/2026-10-19-table-row-and-column-options-now-appear-for-the-row-or-colum.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Table row and column options now appear for the row or column under the pointer, Escape selects the cell before leaving the editor, wide tables keep their add-column control on screen on phones, and a tap near a table's edge on a touch screen edits the cell there instead of adding a row or column

package/corpus/templates/content/docs/product/capabilities/content.comment.page-owned.md

@@ -39,7 +39,7 @@ A reviewer comments on two Blocks in a brief, replies with a Page reference, and
 
 - A Comment thread is owned by one Page and may target one or several Blocks or ranges in its Blocks fields.
 - A thread on a Collection row can instead target one Property value, such as Status or a date. It records the Property's name and the value it had when the thread started. Relations, rollups, and formulas are the exception: what they show depends on who is reading, so the thread records no value and each reader sees their own current one. Once a recorded value changes, the thread shows what it was; once the Property is deleted, the thread says so. It never moves itself onto the newer value. A Property thread has no quoted text, and replies follow the ordinary thread rules.
-- A Collection table shows how many open threads each row has, and marks each cell whose Property has an open thread. Opening either shows the row's Comments, at that cell's thread when there is one. Counts include only rows the viewer can read, so a row they cannot open adds nothing. One Action reads every open thread in a Collection, with each thread's row and target, so an agent need not read row by row.
+- A Collection table shows how many open threads each row has, and marks each cell whose Property has an open thread. The row's count opens the row's Comments. A cell's marker opens a card on the cell with that Property's open threads, where they can be read, replied to, and resolved without leaving the table, and the card can open the row at any of them. Any cell also offers a Comment button to anyone who can comment on the row, which starts a thread on its Property in the same card; on touch screens, where nothing hovers, the button shows on a selected row and starts the thread in the row's peek, or on the row's full page when the Collection opens rows as pages. Counts include only rows the viewer can read, so a row they cannot open adds nothing. One Action reads every open thread in a Collection, with each thread's row and target, so an agent need not read row by row.
 - Rich Comment bodies use the shared Blocks-field grammar; replies and mentions retain the same Page authority.
 - Anchors follow stable Block identity where possible and preserve historical target context after deletion rather than attaching to plausible new text.
 - Resolve, reopen, edit, reply, and notification operations use shared Actions and record attributable change.
@@ -75,6 +75,10 @@ Given a Comment that mentions a teammate and Claude, when it is sent, both names
 
 Given a Collection row whose Status is Blocked, when a commenter starts a thread on Status from the row's peek, the thread reads "Status · Blocked" with no "Highlight unavailable" warning, and the Status cell in the table shows a marker that opens that thread. When Status later changes to Done, the thread reads "was Blocked"; when the Property is deleted, it reads "Status (removed)". A thread started on a Property that is not on the Page, or on a Property and quoted text at once, is rejected.
 
+### Comment on a cell from the table
+
+Given a Collection table and a commenter who cannot edit its rows, when they hover a row's Due cell, a Comment button appears. Posting from the card it opens starts a thread that reads "Due · Nov 2, 2026" without opening the row, and the cell then shows a marker and the row's count goes up. Clicking the marker reopens the card on that thread, where it can be answered, and Open row opens the row's peek on it. When an editor resolves the thread from the same card, the marker and the count clear, and an editor who clicks the cell itself still edits its value.
+
 ### See open Comments from a Collection
 
 Given a Collection where one row has two open threads and a private row has one, a viewer who can read every row but the private one sees "2" beside the first row's name and no count on the private row. Clicking the count opens that row's peek with its Comments showing. Resolving the last open thread clears the count. An agent listing the Collection's Comments in one call gets the same threads, each naming its row and target, and nothing from the private row.

package/corpus/templates/content/docs/product/capabilities/content.revision.suggestions.md

@@ -79,7 +79,9 @@ Saving never ends Suggesting mode; only the author's own switch does. Reloading
 
 Agents propose body suggestions through `suggest-document-edit` (Content action, `mcpTool` with a fully typed agent input schema): the agent supplies the document id, its `baseRevision` from `get-document`, an `idempotencyKey`, and exact find/replace text; the action resolves the match, builds the full before/after Markdown payload and the contextual anchor, and delegates to `create-resource-suggestion` so access, idempotent replay, threads, and notifications stay in one path. Malformed or stale calls fail with errors that name the fix (`SUGGESTION_FIND_NOT_FOUND`, `SUGGESTION_FIND_AMBIGUOUS`, `SUGGESTION_EDIT_PROTOCOL_REQUIRED`). The generic action's Markdown payload errors also state the expected object shape. Focused Content db tests cover creation, idempotent replay, missing and ambiguous finds, the external-caller protocol, and proposals on ordinary database-item Pages. Acceptance tests cover primary Blocks-field reconciliation across multiple collection memberships.
 
-`create-resource-suggestion` accepts `supersedes`: the author's own earlier pending suggestions on the same resource become `superseded`, with a durable decision record and resolved discussion, in the same transaction that creates the replacement. Already decided suggestions are left alone, another author's or another resource's suggestion is refused, and an exact retry replays without superseding twice (`supersede.spec.ts`). Content uses it so a revised Comment AI proposal replaces the requester's earlier pending one from that thread.
+`create-resource-suggestion` accepts `supersedes`: the author's own earlier pending suggestions on the same resource become `superseded`, with a durable decision record and resolved discussion, in the same transaction that creates the replacement. Already decided suggestions are left alone, another author's or another resource's suggestion is refused, and an exact retry replays without superseding twice (`supersede.spec.ts`). Content uses it so a revised Comment AI proposal replaces the requester's earlier pending one from that thread. `create-resource-suggestion-proposal` accepts the same `supersedes` list, so a revised proposal of several edits replaces every pending edit of the one before it in one step.
+
+Comment AI proposals use the same small-edit builder as `suggest-document-edit`. `create-comment-ai-suggestion` takes a list of exact find/replace edits; each is cut down to the words that change, so a request like "hyphenate it throughout" becomes one small suggestion per occurrence instead of one replacement that strikes through and re-inserts the unchanged text between them. Several edits are created as one proposal, and the comment thread shows its summary once above a word diff of each edit, with per-edit Accept and Reject plus Accept remaining and Reject remaining (`comment-ai-flow.test.ts`, `ThreadSuggestion.test.tsx`).
 
 ## Proof plan
 

package/corpus/templates/content/e2e/helpers.ts

@@ -53,6 +53,16 @@ export const RECOVERY_UI = [
   "Something went wrong",
 ];
 
+/**
+ * Actions that need approval run over HTTP only for the signed-in app UI, which
+ * proves itself with this capability cookie. A spec that calls one directly
+ * mints it first, as the app's client does before its writes.
+ */
+export async function presentUiCapability(page: Page): Promise<void> {
+  const response = await page.request.get("/_agent-native/ui-capability");
+  expect(response.ok(), `ui-capability (${response.status()})`).toBe(true);
+}
+
 export async function postAction<T = Record<string, unknown>>(
   page: Page,
   name: string,

package/corpus/templates/content/shared/api.ts

@@ -372,19 +372,25 @@ export interface ContentDatabaseSort {
   direction: ContentDatabaseSortDirection;
 }
 
+export const CONTENT_DATABASE_FILTER_OPERATORS = [
+  "contains",
+  "equals",
+  "does_not_equal",
+  "greater_than",
+  "less_than",
+  "greater_than_or_equal",
+  "less_than_or_equal",
+  "before",
+  "after",
+  "between",
+  "is_checked",
+  "is_unchecked",
+  "is_empty",
+  "is_not_empty",
+] as const;
+
 export type ContentDatabaseFilterOperator =
-  | "contains"
-  | "equals"
-  | "does_not_equal"
-  | "greater_than"
-  | "less_than"
-  | "before"
-  | "after"
-  | "between"
-  | "is_checked"
-  | "is_unchecked"
-  | "is_empty"
-  | "is_not_empty";
+  (typeof CONTENT_DATABASE_FILTER_OPERATORS)[number];
 
 export interface ContentDatabaseFilter {
   key: "name" | (string & {});