@agent-native/core 0.85.6 → 0.86.0

package/corpus/templates/content/actions/update-document.ts

@@ -1,5 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
+import { agentTouchDocument } from "@agent-native/core/collab";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, desc } from "drizzle-orm";
 import { z } from "zod";
@@ -63,6 +64,27 @@ function normalizedBuilderBodyProse(content: string | null | undefined) {
     .trim();
 }
 
+/**
+ * Best-effort quote of the first changed span between two document bodies, used
+ * as the `{ kind: "text", quote }` descriptor so the recent-edit highlight lands
+ * on (or near) the region the agent actually rewrote rather than the doc top.
+ * Returns a short slice of the new content around the first divergence.
+ */
+export function firstChangedQuote(
+  previous: string,
+  next: string,
+  maxLen = 80,
+): string {
+  if (!next) return "";
+  if (previous === next) return next.slice(0, maxLen);
+  let start = 0;
+  const min = Math.min(previous.length, next.length);
+  while (start < min && previous[start] === next[start]) start++;
+  // Skip leading whitespace so the quote begins on visible text.
+  while (start < next.length && /\s/.test(next[start])) start++;
+  return next.slice(start, start + maxLen).trim() || next.slice(0, maxLen);
+}
+
 export function isStaleBuilderImageSourceComponentSave(args: {
   incomingContent: string;
   currentContent: string;
@@ -101,10 +123,17 @@ export default defineAction({
       .optional()
       .describe("Favorite status (true/false)"),
   }),
-  run: async (args): Promise<DocumentUpdateResponse> => {
+  run: async (args, ctx): Promise<DocumentUpdateResponse> => {
     const id = args.id;
     if (!id) throw new Error("--id is required");
 
+    // Only surface AI presence for genuine agent invocations (in-app tool loop,
+    // sub-agents/A2A → "tool"; external MCP agents → "mcp"). The browser editor
+    // autosaves through this same action as "frontend"; those must NOT light the
+    // agent flag.
+    const isAgentCaller =
+      ctx?.caller === "tool" || ctx?.caller === "mcp" || ctx?.caller === "a2a";
+
     if ((await isContentLocalFileMode()) && isLocalDocumentId(id)) {
       const doc = await updateLocalFileDocument(id, args);
       await writeAppState("refresh-signal", { ts: Date.now() });
@@ -252,6 +281,30 @@ export default defineAction({
           content ?? "",
         );
       }
+
+      // Make an agent full-content rewrite visible as a live collaborator. This
+      // path replaces the whole body (not a find/replace), so it can't route
+      // through `searchAndReplace`; it keeps the SQL + reconcile delivery and
+      // publishes agent presence + a lingering recent-edit highlight near the
+      // first changed span. Best-effort — never fail the save on presence.
+      if (isAgentCaller && contentChanged) {
+        try {
+          agentTouchDocument(id, {
+            edit: {
+              descriptor: {
+                kind: "text",
+                quote: firstChangedQuote(existing.content ?? "", content ?? ""),
+              },
+              label: (args.title ?? existing.title) || undefined,
+            },
+          });
+        } catch (error) {
+          console.error(
+            "update-document: agent presence publish failed",
+            error,
+          );
+        }
+      }
     }
 
     const [doc] = await db

package/corpus/templates/content/app/components/editor/DocumentEditor.tsx

@@ -4,6 +4,7 @@ import {
   generateTabId,
   emailToColor,
   emailToName,
+  useAvatarUrl,
   useSession,
   useT,
   agentNativePath,
@@ -464,16 +465,27 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
 
   // Current user info for cursor labels
   const { session } = useSession();
+  const currentUserAvatarUrl = useAvatarUrl(session?.email);
   const currentUser: CollabUser | undefined = session?.email
     ? {
         name: emailToName(session.email),
         email: session.email,
         color: emailToColor(session.email),
+        avatarUrl: currentUserAvatarUrl ?? undefined,
       }
     : undefined;
 
-  // Collaborative editing is write-only for now. Viewers get the SQL snapshot
-  // and skip collab endpoints that reject non-editor access.
+  // Live collaboration for everyone who can open the doc — editors and viewers
+  // alike. Viewers join the shared Y.Doc read-only: they see live keystrokes,
+  // cursors, and presence (Google-Docs style) instead of a lagging SQL snapshot.
+  // The server enforces the split — collab READ routes (state / awareness GET /
+  // users) require viewer access, WRITE routes (update) require editor — so a
+  // viewer's client can subscribe but never push. The editor stays non-editable
+  // for viewers (see `editable={canEdit}` below), and VisualEditor additionally
+  // neutralizes every local Y.Doc mutation for viewers (no seed, no reconcile
+  // apply) so a read-only client can never originate a rejected `/update` POST.
+  // Local-file documents are still excluded (they have no SQL-backed collab doc).
+  const collabEnabled = !isLocalFileDocument;
   const {
     ydoc,
     awareness,
@@ -482,7 +494,7 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
     agentActive,
     agentPresent,
   } = useCollaborativeDoc({
-    docId: canEdit && !isLocalFileDocument ? documentId : "",
+    docId: collabEnabled ? documentId : "",
     requestSource: TAB_ID,
     user: currentUser,
   });
@@ -864,6 +876,112 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
     flushPendingDocumentSave(pending);
   }, [canEdit, documentId, flushPendingDocumentSave]);
 
+  // Last-chance flush when the tab is being hidden or torn down. A normal
+  // debounced save is an async React-Query mutation; if the page unloads before
+  // it resolves the edit is lost. On `pagehide` / `visibilitychange → hidden` we
+  // fire a `keepalive` POST straight to the update-document action so the write
+  // survives navigation/close. Local-file documents persist to disk, not this
+  // endpoint, so they fall back to the best-effort async flush.
+  useEffect(() => {
+    if (!canEdit) return;
+
+    const flushForTeardown = () => {
+      const pending = pendingDocumentSaveRef.current;
+      if (!pending || !pending.canEditWhenQueued) return;
+
+      // Local-file docs can't be flushed via keepalive fetch; best-effort only.
+      if (isLocalFileDocument || isLinkedLocalSourceDocument) {
+        flushPendingDocumentSave(pending);
+        return;
+      }
+
+      // Mirror saveDocumentImmediately's per-field stale guard + diff so we only
+      // send genuinely-changed, non-stale fields.
+      const serverUpdatedAt = documentUpdatedAtRef.current;
+      const titleIsStale =
+        !!serverUpdatedAt &&
+        !!lastSavedTitleRef.current.updatedAt &&
+        serverUpdatedAt > lastSavedTitleRef.current.updatedAt;
+      const contentIsStale =
+        !!serverUpdatedAt &&
+        !!lastSavedContentRef.current.updatedAt &&
+        serverUpdatedAt > lastSavedContentRef.current.updatedAt;
+
+      const updates: Record<string, string> = {};
+      if (pending.title !== lastSavedTitleRef.current.title && !titleIsStale) {
+        updates.title = pending.title;
+      }
+      if (
+        pending.content !== lastSavedContentRef.current.content &&
+        !contentIsStale
+      ) {
+        updates.content = pending.content;
+      }
+      if (Object.keys(updates).length === 0) return;
+
+      clearTimeout(pending.timeout);
+      saveTimeoutRef.current = null;
+      pendingDocumentSaveRef.current = null;
+
+      try {
+        const url = agentNativePath("/_agent-native/actions/update-document");
+        const body = JSON.stringify({ id: documentId, ...updates });
+        const ok = fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            // Tag as a browser-originated call (ctx.caller = "frontend") so this
+            // never lights the AI-editing flag.
+            "X-Agent-Native-Frontend": "1",
+          },
+          body,
+          keepalive: true,
+          cache: "no-store",
+        });
+        // Adopt an optimistic watermark so a re-render doesn't re-queue the same
+        // save; the server bumps updatedAt, and the next poll reconciles it.
+        const optimisticAt = new Date().toISOString();
+        if (updates.title !== undefined) {
+          lastSavedTitleRef.current = {
+            title: pending.title,
+            updatedAt: optimisticAt,
+          };
+        }
+        if (updates.content !== undefined) {
+          lastSavedContentRef.current = {
+            content: pending.content,
+            updatedAt: optimisticAt,
+          };
+        }
+        void Promise.resolve(ok).catch(() => {
+          /* Page is going away; nothing more we can do. */
+        });
+      } catch {
+        // Fall back to the async flush if the keepalive fetch couldn't start.
+        flushPendingDocumentSave(pending);
+      }
+    };
+
+    const onVisibilityChange = () => {
+      if (window.document.visibilityState === "hidden") flushForTeardown();
+    };
+    window.addEventListener("pagehide", flushForTeardown);
+    window.document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      window.removeEventListener("pagehide", flushForTeardown);
+      window.document.removeEventListener(
+        "visibilitychange",
+        onVisibilityChange,
+      );
+    };
+  }, [
+    canEdit,
+    documentId,
+    isLocalFileDocument,
+    isLinkedLocalSourceDocument,
+    flushPendingDocumentSave,
+  ]);
+
   // Collab-aware ingest flush: the `pull-document` action writes a one-shot
   // `flush-request-<id>` app-state key when an external agent wants to ingest
   // the document while a live collab session is open. The DB column can lag
@@ -1299,10 +1417,12 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
                         }
                         onChange={handleContentChange}
                         onSaveContent={handleContentSaveNow}
-                        ydoc={canEdit && !isLocalFileDocument ? ydoc : null}
-                        awareness={
-                          canEdit && !isLocalFileDocument ? awareness : null
-                        }
+                        // Bind the shared Y.Doc/awareness for viewers too — the
+                        // editor is non-editable for them and VisualEditor blocks
+                        // any local Y.Doc mutation, so they get live edits +
+                        // cursors without ever writing. Excludes local-file docs.
+                        ydoc={collabEnabled ? ydoc : null}
+                        awareness={collabEnabled ? awareness : null}
                         user={currentUser}
                         editable={canEdit}
                         localFileMode={isLocalFileDocument}

package/corpus/templates/content/app/components/editor/VisualEditor.tsx

@@ -1,8 +1,12 @@
 import {
   createSharedEditorExtensions,
   useCollabReconcile,
+  usePresence,
+  useRecentEdits,
+  RecentEditHighlights,
   RegistryBlockDataProvider,
   useT,
+  type AttributedRecentEdit,
   type RegistryBlockSideMapBlock,
   type UseCollabReconcileResult,
 } from "@agent-native/core/client";
@@ -745,7 +749,7 @@ interface VisualEditorProps {
   /** Shared awareness instance for collaborative cursors/presence. */
   awareness?: Awareness | null;
   /** Current user info for cursor labels. */
-  user?: { name: string; color: string; email?: string };
+  user?: { name: string; color: string; email?: string; avatarUrl?: string };
   editable?: boolean;
   /** Local-file docs should not persist mount-time/schema normalization echoes. */
   localFileMode?: boolean;
@@ -894,7 +898,12 @@ interface VisualEditorExtensionOptions {
   documentId?: string;
   ydoc?: YDoc | null;
   localAwareness?: Awareness | null;
-  user?: { name: string; color: string; email?: string } | null;
+  user?: {
+    name: string;
+    color: string;
+    email?: string;
+    avatarUrl?: string;
+  } | null;
   onImageComment?: (quotedText: string, offsetTop: number) => void;
   onJoinTitle?: (text: string) => void;
   resolveNotionPageLink?: (notionPageId: string) => NotionPageLink | null;
@@ -1599,6 +1608,7 @@ export function VisualEditor({
 }: VisualEditorProps) {
   const t = useT();
   const [isDraggingMedia, setIsDraggingMedia] = useState(false);
+  const wrapperRef = useRef<HTMLDivElement>(null);
   const onChangeRef = useRef(onChange);
   onChangeRef.current = onChange;
   const onSaveContentRef = useRef(onSaveContent);
@@ -1885,7 +1895,15 @@ export function VisualEditor({
     contentUpdatedAt,
     editable,
     getMarkdown: (e) => docToNfm(e.getJSON() as any),
+    // Read-only viewers join the shared Y.Doc purely to RECEIVE live edits and
+    // cursors; their editor content comes from the server state fetch + peer Yjs
+    // updates, never from SQL reconcile. Any local Y.Doc write from a viewer
+    // would be POSTed to the editor-only `/update` route (→ 403) and could
+    // publish an author-less snapshot, so both write paths are neutered when
+    // `!editable`: this `setContent` (used by both the seed and the reconcile
+    // apply) no-ops, and `shouldSeed` returns false so the seed never runs.
     setContent: (e, value, options) => {
+      if (!editable) return;
       const doc = nfmToDoc(value);
       if (options.addToHistory === false) {
         e.chain()
@@ -1903,6 +1921,7 @@ export function VisualEditor({
     },
     normalizeValue: canonicalizeNfm,
     shouldSeed: ({ value, currentMarkdown, fragmentLength }) =>
+      editable &&
       shouldSeedCollaborativeContent({
         content: value,
         currentMarkdown,
@@ -1912,6 +1931,76 @@ export function VisualEditor({
   });
   guardsRef.current = collabState;
 
+  // ─── Recent-edit highlights (Google-Docs / Figma "just edited this") ─────────
+  //
+  // Other participants — including the AI agent — publish a short ring of recent
+  // edits into their awareness state. `usePresence` surfaces the remote entries,
+  // `useRecentEdits` filters to the non-expired ones, and `RecentEditHighlights`
+  // paints a lingering, fading glow with the editor's name/color flag. For the
+  // agent, `edit-document` / `update-document` publish a `{ kind: "text", quote }`
+  // descriptor, which we resolve to a viewport rect by locating the quote in the
+  // live ProseMirror doc and measuring the span with `coordsAtPos`.
+  const localClientId = ydoc?.clientID ?? null;
+  const { others } = usePresence(localAwareness, localClientId);
+  const recentEdits = useRecentEdits(others);
+
+  const resolveRecentEditRect = useCallback(
+    (edit: AttributedRecentEdit): DOMRect | null => {
+      if (!editor || editor.isDestroyed) return null;
+      if (edit.descriptor.kind !== "text") return null;
+      const quote =
+        typeof edit.descriptor.quote === "string"
+          ? edit.descriptor.quote.trim()
+          : "";
+      if (!quote) return null;
+
+      // Clamp very long quotes — matching a long exact string across the doc is
+      // brittle (whitespace/markdown differences); the leading slice is enough to
+      // anchor the highlight to the right region.
+      const needle = quote.slice(0, 60);
+
+      // Walk the doc's text, tracking absolute positions, to find the needle.
+      const doc = editor.state.doc;
+      let found: { from: number; to: number } | null = null;
+      let acc = "";
+      let accStart = -1;
+      doc.descendants((node, pos) => {
+        if (found) return false;
+        if (!node.isText || typeof node.text !== "string") return true;
+        if (accStart === -1) accStart = pos;
+        acc += node.text;
+        const idx = acc.indexOf(needle);
+        if (idx !== -1) {
+          const from = accStart + idx;
+          found = { from, to: from + needle.length };
+          return false;
+        }
+        // Keep only a tail long enough to catch a needle spanning two text nodes.
+        if (acc.length > needle.length * 2) {
+          const drop = acc.length - needle.length;
+          acc = acc.slice(drop);
+          accStart += drop;
+        }
+        return true;
+      });
+      if (!found) return null;
+
+      try {
+        const { from, to } = found;
+        const start = editor.view.coordsAtPos(from);
+        const end = editor.view.coordsAtPos(Math.max(from, to - 1), 1);
+        const left = Math.min(start.left, end.left);
+        const right = Math.max(start.right, end.right);
+        const top = Math.min(start.top, end.top);
+        const bottom = Math.max(start.bottom, end.bottom);
+        return new DOMRect(left, top, Math.max(1, right - left), bottom - top);
+      } catch {
+        return null;
+      }
+    },
+    [editor],
+  );
+
   // Side-map that feeds the shared registry-block NodeView its typed `data`,
   // lazily parsed from each node's verbatim `__raw` NFM. Edits write the
   // re-serialized MDX back onto the node so the existing NFM save path persists
@@ -2086,8 +2175,14 @@ export function VisualEditor({
 
   return (
     <div
+      ref={wrapperRef}
       className={`visual-editor-wrapper${isDraggingMedia ? " visual-editor-wrapper--dragging" : ""}`}
     >
+      <RecentEditHighlights
+        edits={recentEdits}
+        resolveRect={resolveRecentEditRect}
+        containerRef={wrapperRef}
+      />
       {editable ? (
         <BubbleToolbar editor={editor} onComment={onComment} />
       ) : null}

package/corpus/templates/content/changelog/2026-07-03-agent-document-edits-now-appear-as-a-live-collaborator-prese.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-03
+---
+
+Agent document edits now appear as a live collaborator — presence avatar, editing indicator, and a brief highlight on the changed text

package/corpus/templates/content/changelog/2026-07-03-document-search-and-list-views-load-faster-on-large-workspac.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-03
+---
+
+Document search and list views load faster on large workspaces

package/corpus/templates/content/package.json

@@ -75,8 +75,8 @@
     "@radix-ui/react-toast": "^1.2.14",
     "@radix-ui/react-toggle": "^1.1.9",
     "@radix-ui/react-tooltip": "^1.2.7",
-    "@react-router/dev": "^8.0.1",
-    "@react-router/fs-routes": "^8.0.1",
+    "@react-router/dev": "^8.1.0",
+    "@react-router/fs-routes": "^8.1.0",
     "@swc/core": "^1.13.3",
     "@tailwindcss/typography": "^0.5.16",
     "@tailwindcss/vite": "catalog:",
@@ -93,7 +93,7 @@
     "oxfmt": "catalog:",
     "react": "catalog:",
     "react-dom": "catalog:",
-    "react-router": "^8.0.1",
+    "react-router": "^8.1.0",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "catalog:",

package/corpus/templates/content/server/plugins/db.ts

@@ -1,6 +1,29 @@
-import { runMigrations } from "@agent-native/core/db";
+import {
+  ensureAdditiveColumns,
+  getDbExec,
+  runMigrations,
+} from "@agent-native/core/db";
 
 import { repairUnseededBlocksFields } from "../../actions/_property-utils.js";
+import * as schema from "../db/schema.js";
+
+/**
+ * Every Drizzle table exported from schema.ts. Filters out type-only and
+ * helper exports the same way db.spec.ts's `isDrizzleTable` regression guard
+ * does: a real table carries a Symbol-keyed drizzle metadata bag, plain
+ * exports don't.
+ */
+function isDrizzleTable(value: unknown): value is object {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    Object.getOwnPropertySymbols(value).some((s) =>
+      s.toString().includes("drizzle"),
+    )
+  );
+}
+
+const schemaTables = Object.values(schema).filter(isDrizzleTable);
 
 function scheduleBlocksRepairRetry(attempt = 1): void {
   const delayMs = Math.min(30_000 * attempt, 5 * 60_000);
@@ -14,6 +37,11 @@ function scheduleBlocksRepairRetry(attempt = 1): void {
   }
 }
 
+// Convention: every new migration below MUST set a unique `name:` slug (see
+// packages/core/src/db/migrations.ts for the full rationale). Version numbers
+// alone are not a safe identity across parallel branches that each extend
+// this list independently — see the analytics db.ts v75-v83 incident this
+// convention was introduced to prevent.
 const runContentMigrations = runMigrations(
   [
     {
@@ -598,11 +626,39 @@ const runContentSourceMigrations = runMigrations(
   { table: "content_source_migrations" },
 );
 
+/**
+ * The migration lists above are the authoritative source for tables, indexes,
+ * and data transforms. `ensureAdditiveColumns` runs after they complete as a
+ * belt-and-braces safety net for the failure mode where a column is added to
+ * schema.ts without a matching hand-written ALTER migration, which silently
+ * 500s every query touching a pre-existing production table. It only ever
+ * adds missing columns — never drops, renames, or retypes anything — and any
+ * failure here is logged and swallowed so it can never fail boot.
+ */
 export default async function contentDatabasePlugin(
   nitroApp: Parameters<typeof runContentMigrations>[0],
 ) {
   await runContentMigrations(nitroApp);
   await runContentSourceMigrations(nitroApp);
+  try {
+    const summary = await ensureAdditiveColumns({
+      db: getDbExec(),
+      tables: schemaTables,
+    });
+    if (summary.errors.length > 0) {
+      console.warn(
+        "[db] ensureAdditiveColumns completed with errors:",
+        summary.errors,
+      );
+    }
+  } catch (err) {
+    // Never fail boot over the safety net itself — the authoritative
+    // migrations above already ran.
+    console.warn(
+      "[db] ensureAdditiveColumns failed (non-fatal):",
+      err instanceof Error ? err.message : err,
+    );
+  }
   // One-time, boot-time repair: seed the primary "Content" Blocks field for any
   // legacy database that has never been seeded (blocks_seeded = 0). Idempotent —
   // the atomic claim in seedDefaultBlocksField makes re-runs no-ops, and it