@agent-native/core 0.81.2 → 0.82.0

package/corpus/templates/clips/server/lib/resumable-session.ts

@@ -0,0 +1,39 @@
+import {
+  deleteAppState,
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+
+export interface StoredResumableSession {
+  providerId: string;
+  sessionId: string;
+  meta: Record<string, unknown>;
+  bytesUploaded: number;
+  lastCommittedIndex?: number;
+}
+
+const key = (recordingId: string) => `resumable-session-${recordingId}`;
+
+export async function getResumableSession(
+  recordingId: string,
+): Promise<StoredResumableSession | null> {
+  const raw = await readAppState(key(recordingId));
+  if (!raw || typeof raw !== "object") return null;
+  return raw as unknown as StoredResumableSession;
+}
+
+export async function setResumableSession(
+  recordingId: string,
+  session: StoredResumableSession,
+): Promise<void> {
+  await writeAppState(
+    key(recordingId),
+    session as unknown as Record<string, unknown>,
+  );
+}
+
+export async function deleteResumableSession(
+  recordingId: string,
+): Promise<void> {
+  await deleteAppState(key(recordingId));
+}

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/abort.post.ts

@@ -24,6 +24,7 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
+import { deleteResumableSession } from "../../../../lib/resumable-session.js";
 
 export default defineEventHandler(async (event: H3Event) => {
   const recordingId = getRouterParam(event, "recordingId");
@@ -70,6 +71,7 @@ export default defineEventHandler(async (event: H3Event) => {
     const cleared = await deleteAppStateByPrefix(
       `recording-chunks-${recordingId}-`,
     );
+    await deleteResumableSession(recordingId).catch(() => {});
 
     const now = new Date().toISOString();
     await db

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -17,6 +17,7 @@ import {
   readAppState,
   writeAppState,
 } from "@agent-native/core/application-state";
+import { getActiveFileUploadProvider } from "@agent-native/core/file-upload";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { normalizeChunkUploadNumber } from "@shared/recording-core.js";
 import { MAX_UPLOAD_BYTES as MAX_RECORDING_UPLOAD_BYTES } from "@shared/upload-limits.js";
@@ -40,12 +41,23 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
+import {
+  getResumableSession,
+  setResumableSession,
+  type StoredResumableSession,
+} from "../../../../lib/resumable-session.js";
 import {
   shouldRejectVideoUploadWithoutStorage,
   STORAGE_SETUP_REQUIRED_REASON,
 } from "../../../../lib/video-storage.js";
+
 const RECORDING_TOO_LARGE_REASON = `Recording exceeds the ${Math.round(MAX_RECORDING_UPLOAD_BYTES / (1024 * 1024))} MB size limit. Please record a shorter clip.`;
 
+// Netlify functions have a 6 MB buffered request cap, but binary requests
+// are base64 encoded by the gateway and effectively cap out around 4.5 MB.
+// Keep our own cap lower so dev/local failures match production.
+const MAX_CHUNK_BYTES = 4 * 1024 * 1024;
+
 const ALLOWED_RECORDING_MIME_TYPES = new Set([
   "video/webm",
   "video/mp4",
@@ -115,10 +127,6 @@ export default defineEventHandler(async (event: H3Event) => {
     throw createError({ statusCode: 400, message: "Invalid chunk index" });
   }
 
-  // Netlify functions have a 6 MB buffered request cap, but binary requests
-  // are base64 encoded by the gateway and effectively cap out around 4.5 MB.
-  // Keep our own cap lower so dev/local failures match production.
-  const MAX_CHUNK_BYTES = 4 * 1024 * 1024;
   const contentLength = Number(getHeader(event, "content-length") || 0);
   if (contentLength > MAX_CHUNK_BYTES) {
     setResponseStatus(event, 413);
@@ -164,6 +172,20 @@ export default defineEventHandler(async (event: H3Event) => {
       throw createError({ statusCode: 404, message: "Recording not found" });
     }
 
+    // Resumable streaming path — forward chunks directly to the provider.
+    const resumableSession = await getResumableSession(recordingId);
+    if (resumableSession) {
+      return handleResumableChunk(
+        event,
+        resumableSession,
+        recordingId,
+        index,
+        isFinal,
+        mimeType,
+        query,
+      );
+    }
+
     const failedUploadResponse = (reason: string, bytes?: number) => {
       setResponseStatus(
         event,
@@ -183,6 +205,13 @@ export default defineEventHandler(async (event: H3Event) => {
       );
     }
 
+    // Already finalized — retried final chunk after session was deleted. Skip
+    // buffered path writes so recording-upload-* state stays correct.
+    if (existing.status === "ready") {
+      return { ok: true, finalized: true };
+    }
+
+    // Store chunks in application_state, assemble on finalize.
     if (await shouldRejectVideoUploadWithoutStorage()) {
       const now = new Date().toISOString();
       await db
@@ -362,10 +391,7 @@ export default defineEventHandler(async (event: H3Event) => {
 
       await db
         .update(schema.recordings)
-        .set({
-          uploadProgress: progress,
-          updatedAt: new Date().toISOString(),
-        })
+        .set({ uploadProgress: progress, updatedAt: new Date().toISOString() })
         .where(
           and(
             eq(schema.recordings.id, recordingId),
@@ -399,21 +425,9 @@ export default defineEventHandler(async (event: H3Event) => {
       if (failedResponse) return failedResponse;
       debugLog("[chunk] isFinal — invoking finalize", { recordingId });
       try {
-        const result = await finalizeRecording.run({
-          id: recordingId,
-          durationMs: normalizeChunkUploadNumber(query.durationMs),
-          width: normalizeChunkUploadNumber(query.width),
-          height: normalizeChunkUploadNumber(query.height),
-          hasAudio:
-            query.hasAudio === undefined
-              ? undefined
-              : query.hasAudio === "1" || query.hasAudio === "true",
-          hasCamera:
-            query.hasCamera === undefined
-              ? undefined
-              : query.hasCamera === "1" || query.hasCamera === "true",
-          mimeType,
-        });
+        const result = await finalizeRecording.run(
+          buildFinalizeArgs(recordingId, mimeType, query),
+        );
         debugLog("[chunk] finalize ok", {
           recordingId,
           videoUrl: (result as any)?.videoUrl,
@@ -510,11 +524,154 @@ export default defineEventHandler(async (event: H3Event) => {
       }
     }
 
-    return {
-      ok: true,
-      finalized: false,
-      index,
-      bytes: bytes.byteLength,
-    };
+    return { ok: true, finalized: false, index, bytes: bytes.byteLength };
   });
 });
+
+function buildFinalizeArgs(
+  recordingId: string,
+  mimeType: string,
+  query: Record<string, unknown>,
+) {
+  return {
+    id: recordingId,
+    durationMs: normalizeChunkUploadNumber(query.durationMs),
+    width: normalizeChunkUploadNumber(query.width),
+    height: normalizeChunkUploadNumber(query.height),
+    hasAudio:
+      query.hasAudio === undefined
+        ? undefined
+        : query.hasAudio === "1" || query.hasAudio === "true",
+    hasCamera:
+      query.hasCamera === undefined
+        ? undefined
+        : query.hasCamera === "1" || query.hasCamera === "true",
+    mimeType,
+  };
+}
+
+// Resumable streaming path: each chunk is forwarded directly to the upload
+// provider. Always returns a response — never falls through to the buffered path.
+async function handleResumableChunk(
+  event: H3Event,
+  session: StoredResumableSession,
+  recordingId: string,
+  index: number,
+  isFinal: boolean,
+  mimeType: string,
+  query: Record<string, unknown>,
+) {
+  const uploadProvider = getActiveFileUploadProvider();
+  console.log(
+    `[resumable-chunk-${recordingId}] resumable session exists - bytesUploaded=${session.bytesUploaded} index=${index} isFinal=${isFinal}`,
+  );
+
+  const raw = await readRawBody(event, false);
+  const bytes: Uint8Array = raw ?? new Uint8Array(0);
+
+  if (!isFinal && bytes.byteLength === 0) {
+    throw createError({ statusCode: 400, message: "Empty chunk body" });
+  }
+
+  if (isFinal && bytes.byteLength === 0) {
+    // 0-byte sentinel from the recorder after stop(). All data chunks have
+    // already been PUT to the provider; send Content-Range: bytes */<total>
+    // to close the session before handing off to finalize-recording.
+    const closeRes = await uploadProvider!.resumable!.relayChunk(
+      { sessionId: session.sessionId, meta: session.meta },
+      `bytes */${session.bytesUploaded}`,
+      new Uint8Array(0),
+    );
+    if (!closeRes.ok) {
+      console.error(
+        `[resumable-chunk-${recordingId}] session close failed (${closeRes.status})`,
+      );
+      setResponseStatus(event, 502);
+      return {
+        ok: false,
+        error: `Resumable session close failed (${closeRes.status})`,
+      };
+    }
+  } else {
+    // Idempotent replay guard: a client retry (after a lost response) can
+    // re-send a chunk we already committed. Re-PUTing it at the new offset
+    // would corrupt the file — detect the duplicate by index and skip the PUT.
+    // Chunks are strictly sequential, so any index <= last committed is a replay.
+    // A replayed non-final is acked here; a replayed final falls through to
+    // finalize, which is idempotent.
+    const isReplay = index <= (session.lastCommittedIndex ?? -1);
+    if (isReplay) {
+      console.warn(
+        `[resumable-chunk-${recordingId}] duplicate chunk ${index}, acking without re-upload`,
+      );
+      if (!isFinal) {
+        return {
+          ok: true,
+          finalized: false,
+          index,
+          bytes: bytes.byteLength,
+          duplicate: true,
+        };
+      }
+    } else {
+      // Forward the data chunk to the provider and advance offsets only after
+      // the provider confirms receipt (308 Resume Incomplete for non-final, 2xx for final).
+      const start = session.bytesUploaded;
+      const end = start + bytes.byteLength - 1;
+      const contentRange = isFinal
+        ? `bytes ${start}-${end}/${start + bytes.byteLength}`
+        : `bytes ${start}-${end}/*`;
+
+      const putT0 = Date.now();
+      const putResult = await uploadProvider!.resumable!.relayChunk(
+        { sessionId: session.sessionId, meta: session.meta },
+        contentRange,
+        bytes,
+        { mimeType: mimeType.split(";")[0].trim() },
+      );
+      console.log(
+        `[resumable-chunk-${recordingId}] PUT ${Date.now() - putT0}ms status=${putResult.status} range="${contentRange}"`,
+      );
+
+      const resultOk = isFinal
+        ? putResult.ok && putResult.status !== 308
+        : putResult.ok;
+      if (!resultOk) {
+        setResponseStatus(event, 502);
+        return {
+          ok: false,
+          error: `Chunk upload failed (${putResult.status})`,
+        };
+      }
+
+      await setResumableSession(recordingId, {
+        ...session,
+        ...(putResult.updatedMeta
+          ? { meta: { ...session.meta, ...putResult.updatedMeta } }
+          : {}),
+        bytesUploaded: start + bytes.byteLength,
+        lastCommittedIndex: index,
+      });
+
+      if (!isFinal) {
+        return { ok: true, finalized: false, index, bytes: bytes.byteLength };
+      }
+    }
+  }
+
+  // isFinal — delegate to finalize-recording, which reads the resumable
+  // session and calls provider.resumable.completeSession.
+  try {
+    const result = await finalizeRecording.run(
+      buildFinalizeArgs(recordingId, mimeType, query),
+    );
+    return { ok: true, finalized: true, ...result };
+  } catch (err) {
+    console.error(`[resumable-chunk-${recordingId}] finalize failed:`, err);
+    setResponseStatus(event, 500);
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : "Finalize failed",
+    };
+  }
+}

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/reset-chunks.post.ts

@@ -44,6 +44,7 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
+import { deleteResumableSession } from "../../../../lib/resumable-session.js";
 
 interface CompressionMeta {
   originalBytes?: number;
@@ -112,6 +113,9 @@ export default defineEventHandler(async (event: H3Event) => {
     const cleared = await deleteAppStateByPrefix(
       `recording-chunks-${recordingId}-`,
     );
+    // Clear any stale resumable session so a buffered retry does not
+    // accidentally route through handleResumableChunk with stale offsets.
+    await deleteResumableSession(recordingId).catch(() => {});
 
     // Reset the per-recording upload progress so the UI poller sees the
     // re-upload restart from 0 and doesn't briefly show "100% then

package/corpus/templates/clips/shared/recording-core.ts

@@ -46,6 +46,11 @@ export function pickMimeType(): string {
   return "";
 }
 
+/** How the client delivers recorded data to the server.
+ *  - `"streaming"` — chunks are flushed to GCS during recording via a resumable session
+ *  - `"buffered"`  — full blob assembled after stop() and uploaded in slices */
+export type UploadMode = "streaming" | "buffered";
+
 /** Query params understood by the chunk-upload route
  * (`/api/uploads/:id/chunk`). This is the on-the-wire contract — the route in
  * `server/routes/api/uploads/[recordingId]/chunk.post.ts` reads exactly these. */

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

@@ -22,7 +22,7 @@ import {
   useRef,
   useState,
 } from "react";
-import type { ClipboardEvent } from "react";
+import type { ClipboardEvent, MutableRefObject } from "react";
 import { useNavigate } from "react-router";
 import { toast } from "sonner";
 
@@ -69,6 +69,50 @@ interface DocumentEditorProps {
   documentId: string;
 }
 
+type FieldSaveWatermark = { title: string; updatedAt: string | null };
+type ContentSaveWatermark = { content: string; updatedAt: string | null };
+
+function adoptConfirmedSaveWatermarks({
+  saved,
+  savedAt,
+  title,
+  content,
+  updates,
+  lastSavedTitleRef,
+  lastSavedContentRef,
+}: {
+  saved: Document | undefined;
+  savedAt: string;
+  title: string;
+  content: string;
+  updates: Record<string, string>;
+  lastSavedTitleRef: MutableRefObject<FieldSaveWatermark>;
+  lastSavedContentRef: MutableRefObject<ContentSaveWatermark>;
+}) {
+  if (updates.title !== undefined) {
+    lastSavedTitleRef.current = { title, updatedAt: savedAt };
+  } else if (
+    updates.content !== undefined &&
+    saved?.title === lastSavedTitleRef.current.title
+  ) {
+    lastSavedTitleRef.current = {
+      ...lastSavedTitleRef.current,
+      updatedAt: savedAt,
+    };
+  }
+  if (updates.content !== undefined) {
+    lastSavedContentRef.current = { content, updatedAt: savedAt };
+  } else if (
+    updates.title !== undefined &&
+    saved?.content === lastSavedContentRef.current.content
+  ) {
+    lastSavedContentRef.current = {
+      ...lastSavedContentRef.current,
+      updatedAt: savedAt,
+    };
+  }
+}
+
 function DocumentEditorSkeleton() {
   return (
     <div className="flex min-h-0 flex-1 flex-col bg-background">
@@ -686,12 +730,15 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
       const saved = await persistDocumentUpdates(updates, options);
       // Adopt the server updatedAt per saved field.
       const savedAt = saved?.updatedAt ?? new Date().toISOString();
-      if (updates.title !== undefined) {
-        lastSavedTitleRef.current = { title, updatedAt: savedAt };
-      }
-      if (updates.content !== undefined) {
-        lastSavedContentRef.current = { content, updatedAt: savedAt };
-      }
+      adoptConfirmedSaveWatermarks({
+        saved,
+        savedAt,
+        title,
+        content,
+        updates,
+        lastSavedTitleRef,
+        lastSavedContentRef,
+      });
 
       // Push-on-save: when auto-sync is on, trigger a Notion push
       // immediately after the save lands in SQL. This eliminates the
@@ -818,15 +865,15 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
               if (Object.keys(updates).length > 0) {
                 const saved = await persistDocumentUpdates(updates);
                 const savedAt = saved?.updatedAt ?? new Date().toISOString();
-                if (updates.title !== undefined) {
-                  lastSavedTitleRef.current = { title, updatedAt: savedAt };
-                }
-                if (updates.content !== undefined) {
-                  lastSavedContentRef.current = {
-                    content,
-                    updatedAt: savedAt,
-                  };
-                }
+                adoptConfirmedSaveWatermarks({
+                  saved,
+                  savedAt,
+                  title,
+                  content,
+                  updates,
+                  lastSavedTitleRef,
+                  lastSavedContentRef,
+                });
               }
             } finally {
               // Acknowledge the flush even if nothing changed — the SQL row is

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

@@ -59,6 +59,10 @@ import {
 } from "@/hooks/use-documents";
 import { cn } from "@/lib/utils";
 
+import {
+  getDocumentSidebarSections,
+  isDirectLocalDocument,
+} from "./document-sidebar-sections";
 import { DocumentSidebarIcon, DocumentTreeItem } from "./DocumentTreeItem";
 import { NotionButton } from "./NotionButton";
 
@@ -114,22 +118,6 @@ function collectDocumentSubtreeIds(documents: Document[], rootId: string) {
   return deletedIds;
 }
 
-function isDirectLocalDocument(document: Pick<Document, "id" | "source">) {
-  return (
-    document.source?.mode === "local-files" &&
-    (document.id.startsWith("local-file:") ||
-      document.id.startsWith("local-folder:"))
-  );
-}
-
-function isImportedLocalSourceDocument(
-  document: Pick<Document, "id" | "source">,
-) {
-  return (
-    document.source?.mode === "local-files" && !isDirectLocalDocument(document)
-  );
-}
-
 type SidebarSectionId =
   | "local-files"
   | "shared-copies"
@@ -210,24 +198,23 @@ export function DocumentSidebar({
   );
 
   const treeDocuments = filterDocumentTreeDocuments(documents);
-  const localFileMode = documents.some(isDirectLocalDocument);
-  const localSourceDocuments = localFileMode
-    ? treeDocuments.filter(isDirectLocalDocument)
-    : treeDocuments.filter(isImportedLocalSourceDocument);
-  const databaseDocuments = localFileMode
-    ? treeDocuments.filter((document) => !isDirectLocalDocument(document))
-    : treeDocuments.filter(
-        (document) => !isImportedLocalSourceDocument(document),
-      );
+  const {
+    localFileMode,
+    localSourceDocuments,
+    databaseDocuments,
+    favorites,
+    showFavorites,
+  } = getDocumentSidebarSections(documents, treeDocuments);
   const localFileTree = buildDocumentTree(localSourceDocuments);
   const databaseTree = buildDocumentTree(databaseDocuments);
   const privateTree = databaseTree.filter((node) => node.visibility !== "org");
   const organizationTree = databaseTree.filter(
     (node) => node.visibility === "org",
   );
-  const favorites = documents.filter(
-    (d) => d.isFavorite && (localFileMode || !isImportedLocalSourceDocument(d)),
-  );
+  // Match the tree rows' right-side inset so favorite titles clip inside the
+  // visible sidebar instead of widening the scroll surface.
+  const favoriteRowWidth =
+    width === undefined ? undefined : Math.max(224, width - 8);
   const activeDocument = activeDocumentId
     ? documents.find((doc) => doc.id === activeDocumentId)
     : null;
@@ -878,21 +865,29 @@ export function DocumentSidebar({
           ) : (
             <>
               {/* Favorites */}
-              {!localFileMode && favorites.length > 0 && (
-                <div className="mb-2">
-                  <div className="px-3 py-1.5 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground flex items-center gap-1">
+              {showFavorites && (
+                <div className="mb-2 min-w-0">
+                  <div className="flex min-w-0 items-center gap-1 px-3 py-1.5 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">
                     <IconStar size={10} />
-                    {t("sidebar.favorites")}
+                    <span className="min-w-0 flex-1 truncate">
+                      {t("sidebar.favorites")}
+                    </span>
                   </div>
                   {favorites.map((doc) => (
                     <button
                       key={doc.id}
                       className={cn(
-                        "w-full flex items-center gap-2 px-4 py-[5px] text-sm text-start rounded-md",
+                        "flex w-full min-w-0 items-center gap-2 rounded-md px-4 py-[5px] text-start text-sm",
                         doc.id === activeDocumentId
                           ? "bg-accent text-accent-foreground"
                           : "text-muted-foreground hover:bg-accent/50 hover:text-foreground",
                       )}
+                      style={{
+                        width:
+                          favoriteRowWidth === undefined
+                            ? undefined
+                            : `${favoriteRowWidth}px`,
+                      }}
                       onClick={() => {
                         navigateToDocument(doc.id);
                         onNavigate?.();

package/corpus/templates/content/app/components/sidebar/document-sidebar-sections.ts

@@ -0,0 +1,47 @@
+import type { Document } from "@shared/api";
+
+export function isDirectLocalDocument(
+  document: Pick<Document, "id" | "source">,
+) {
+  return (
+    document.source?.mode === "local-files" &&
+    (document.id.startsWith("local-file:") ||
+      document.id.startsWith("local-folder:"))
+  );
+}
+
+export function isImportedLocalSourceDocument(
+  document: Pick<Document, "id" | "source">,
+) {
+  return (
+    document.source?.mode === "local-files" && !isDirectLocalDocument(document)
+  );
+}
+
+export function getDocumentSidebarSections(
+  documents: Document[],
+  treeDocuments: Document[] = documents,
+) {
+  const localFileMode = documents.some(isDirectLocalDocument);
+  const localSourceDocuments = localFileMode
+    ? treeDocuments.filter(isDirectLocalDocument)
+    : treeDocuments.filter(isImportedLocalSourceDocument);
+  const databaseDocuments = localFileMode
+    ? treeDocuments.filter((document) => !isDirectLocalDocument(document))
+    : treeDocuments.filter(
+        (document) => !isImportedLocalSourceDocument(document),
+      );
+  const favorites = documents.filter(
+    (document) =>
+      document.isFavorite &&
+      (localFileMode || !isImportedLocalSourceDocument(document)),
+  );
+
+  return {
+    localFileMode,
+    localSourceDocuments,
+    databaseDocuments,
+    favorites,
+    showFavorites: favorites.length > 0,
+  };
+}

package/corpus/templates/content/app/hooks/use-documents.ts

@@ -12,6 +12,36 @@ import { toast } from "sonner";
 
 import { useRestoreContentDatabase } from "./use-content-database";
 
+const LIST_DOCUMENTS_QUERY_KEY = ["action", "list-documents", undefined];
+
+export function mergeDocumentIntoDocumentCache(
+  old: unknown,
+  document: Document,
+) {
+  return old && typeof old === "object" ? { ...old, ...document } : document;
+}
+
+export function mergeDocumentIntoListDocumentsCache(
+  old: unknown,
+  document: Document,
+) {
+  if (Array.isArray(old)) {
+    return old.map((item: Document) =>
+      item.id === document.id ? { ...item, ...document } : item,
+    );
+  }
+
+  if (!old || typeof old !== "object") return old;
+  const cached = old as { documents?: unknown };
+  if (!Array.isArray(cached.documents)) return old;
+
+  const nextDocuments = cached.documents.map((item: Document) =>
+    item.id === document.id ? { ...item, ...document } : item,
+  );
+
+  return { ...(old as object), documents: nextDocuments };
+}
+
 export function useDocuments() {
   return useActionQuery<Document[]>("list-documents", undefined, {
     select: (data: any) => {
@@ -42,6 +72,13 @@ export function useUpdateDocument() {
     DocumentUpdateRequest & { id: string }
   >("update-document", {
     onSuccess: (data, variables) => {
+      queryClient.setQueryData(
+        ["action", "get-document", { id: variables.id }],
+        (old: unknown) => mergeDocumentIntoDocumentCache(old, data),
+      );
+      queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, (old: unknown) =>
+        mergeDocumentIntoListDocumentsCache(old, data),
+      );
       queryClient.invalidateQueries({
         queryKey: ["action", "get-document", { id: variables.id }],
       });

package/corpus/templates/content/changelog/2026-06-30-sidebar-favorites-now-keep-long-titles-tidy-and-stay-in-sync.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-06-30
+---
+
+Sidebar favorites now keep long titles tidy and stay in sync with saved page titles.