@agent-native/core-corpus 0.210.2 → 0.211.0

package/corpus/templates/mail/app/lib/thread-cache.ts

@@ -1,5 +1,10 @@
 import { appApiPath } from "@agent-native/core/client/api-path";
+import {
+  currentActionQueryCacheBinding,
+  recordActionQueryBrowserPersist,
+} from "@agent-native/core/client/hooks";
 import type { EmailMessage } from "@shared/types";
+import type { QueryClient } from "@tanstack/react-query";
 import { useEffect, useState } from "react";
 
 import { beginProviderSnapshot } from "@/lib/provider-snapshot";
@@ -14,6 +19,8 @@ type CacheEntry = {
 type ThreadFetchResult = {
   messages: EmailMessage[];
   providerSnapshotId: number;
+  response?: Response;
+  cacheBinding?: object;
 };
 
 type WarmTarget = string | { id: string; accountEmail?: string };
@@ -21,6 +28,12 @@ type WarmTarget = string | { id: string; accountEmail?: string };
 const BACKGROUND_RATE_LIMIT_COOLDOWN_MS = 90 * 1000;
 const BACKGROUND_AUTH_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
 const WARM_BATCH_LIMIT = 4;
+// Recently fetched threads are mirrored into the action query cache, whose
+// per-user persisted record (cleared on sign-out) paints them after a restart.
+// A restored thread is only a placeholder until its refetch lands.
+const PERSISTED_THREADS_KEY = ["action", "mail-thread-messages"] as const;
+const PERSISTED_THREAD_LIMIT = 20;
+let persistClient: QueryClient | undefined;
 
 type Globals = {
   __mailThreadCacheFormat?: number;
@@ -85,6 +98,83 @@ function keysForThread(threadId: string): string[] {
   ).filter((key) => threadIdFromCacheKey(key) === threadId);
 }
 
+/** Call before the persisted query cache restores, so restored threads keep `gcTime: Infinity`. */
+export function bindThreadCacheQueryClient(client: QueryClient): void {
+  persistClient = client;
+  client.setQueryDefaults([...PERSISTED_THREADS_KEY], { gcTime: Infinity });
+}
+
+function persistedThreadQueryKey(key: string) {
+  return [
+    ...PERSISTED_THREADS_KEY,
+    sessionScope ?? null,
+    accountScope ?? null,
+    key,
+  ];
+}
+
+function persistThread(
+  key: string,
+  entry: CacheEntry,
+  result: ThreadFetchResult,
+) {
+  if (!persistClient || sessionScope === undefined) return;
+  const queryCache = persistClient.getQueryCache();
+  const queryKey = persistedThreadQueryKey(key);
+  persistClient.setQueryData(queryKey, entry.messages, {
+    updatedAt: entry.fetchedAt,
+  });
+  const query = queryCache.find({ queryKey, exact: true });
+  if (query) {
+    recordActionQueryBrowserPersist(
+      query,
+      result.response,
+      result.cacheBinding,
+    );
+  }
+  const persisted = queryCache
+    .findAll({ queryKey: [...PERSISTED_THREADS_KEY] })
+    .sort((a, b) => b.state.dataUpdatedAt - a.state.dataUpdatedAt);
+  for (const evicted of persisted.slice(PERSISTED_THREAD_LIMIT)) {
+    queryCache.remove(evicted);
+  }
+}
+
+function forgetPersistedThreadsForThread(threadId: string) {
+  if (!persistClient) return;
+  const queryCache = persistClient.getQueryCache();
+  const queryKeyIndex = PERSISTED_THREADS_KEY.length + 2;
+  for (const query of queryCache.findAll({
+    queryKey: [...PERSISTED_THREADS_KEY],
+  })) {
+    const key = query.queryKey[queryKeyIndex];
+    if (typeof key !== "string" || threadIdFromCacheKey(key) !== threadId) {
+      continue;
+    }
+    persistClient.removeQueries({ queryKey: query.queryKey, exact: true });
+  }
+}
+
+function cachedEntry(key: string): CacheEntry | undefined {
+  const hit = cache.get(key);
+  if (hit || !persistClient || sessionScope === undefined) return hit;
+  const query = persistClient
+    .getQueryCache()
+    .find({ queryKey: persistedThreadQueryKey(key), exact: true });
+  const messages = query?.state.data;
+  if (!query || !Array.isArray(messages)) return undefined;
+  const restored = {
+    messages: messages as EmailMessage[],
+    fetchedAt: query.state.dataUpdatedAt,
+  };
+  cache.set(key, restored);
+  const parsed = JSON.parse(key) as [unknown, string | null, string];
+  if (canRunBackgroundFetch() && !inflight.has(key)) {
+    void backgroundRefresh(parsed[2], parsed[1] ?? undefined);
+  }
+  return restored;
+}
+
 export function getThreadCacheOwner(): string | null {
   return g.__mailThreadOwner ?? null;
 }
@@ -200,6 +290,7 @@ async function fetchThread(
   accountEmail?: string,
 ): Promise<ThreadFetchResult> {
   const providerSnapshotId = beginProviderSnapshot();
+  const cacheBinding = currentActionQueryCacheBinding();
   const params = new URLSearchParams();
   if (accountEmail) params.set("accountEmail", accountEmail);
   const suffix = params.toString() ? `?${params}` : "";
@@ -231,7 +322,12 @@ async function fetchThread(
       retryAfterMs;
     throw error;
   }
-  return { messages: await res.json(), providerSnapshotId };
+  return {
+    messages: await res.json(),
+    providerSnapshotId,
+    response: res,
+    cacheBinding,
+  };
 }
 
 function clearLegacyThreadStorage() {
@@ -247,7 +343,7 @@ export function getCachedThread(
   threadId: string,
   accountEmail?: string,
 ): EmailMessage[] | undefined {
-  return cache.get(cacheKey(threadId, accountEmail))?.messages;
+  return cachedEntry(cacheKey(threadId, accountEmail))?.messages;
 }
 
 export function setCachedThread(
@@ -292,6 +388,7 @@ export function invalidateCachedThread(threadId: string) {
     versions.set(key, getVersion(key) + 1);
     notify(key);
   }
+  forgetPersistedThreadsForThread(threadId);
 }
 
 const STALE_AFTER = 60 * 1000;
@@ -301,7 +398,7 @@ export function ensureThread(
   accountEmail?: string,
 ): Promise<EmailMessage[]> {
   const key = cacheKey(threadId, accountEmail);
-  const cached = cache.get(key);
+  const cached = cachedEntry(key);
   if (cached) {
     if (
       Date.now() - cached.fetchedAt > STALE_AFTER &&
@@ -321,11 +418,13 @@ export function ensureThread(
         clearOwnedInflight(key, p);
         return result;
       }
-      cache.set(key, {
+      const entry = {
         messages: result.messages,
         fetchedAt: Date.now(),
         providerSnapshotId: result.providerSnapshotId,
-      });
+      };
+      cache.set(key, entry);
+      persistThread(key, entry, result);
       clearOwnedInflight(key, p);
       notify(key);
       return result;
@@ -356,11 +455,13 @@ function backgroundRefresh(
         return result;
       }
       const prev = cache.get(key);
-      cache.set(key, {
+      const entry = {
         messages: result.messages,
         fetchedAt: Date.now(),
         providerSnapshotId: result.providerSnapshotId,
-      });
+      };
+      cache.set(key, entry);
+      persistThread(key, entry, result);
       clearOwnedInflight(key, p);
       const prevJson = prev ? JSON.stringify(prev.messages) : "";
       const nextJson = JSON.stringify(result.messages);
@@ -389,7 +490,7 @@ export function warmThreads(targets: WarmTarget[], concurrency = 2) {
     .map(normalizeTarget)
     .filter((target) => {
       const key = cacheKey(target.id, target.accountEmail);
-      return !cache.has(key) && !inflight.has(key);
+      return !cachedEntry(key) && !inflight.has(key);
     })
     .slice(0, WARM_BATCH_LIMIT);
   if (queue.length === 0) return;
@@ -448,7 +549,7 @@ export function useThreadCache(
       isLoading: false,
     };
   }
-  const hit = cache.get(key!);
+  const hit = cachedEntry(key!);
   if (hit) {
     return {
       messages: hit.messages,

package/corpus/templates/mail/app/root.tsx

@@ -49,7 +49,11 @@ import {
 } from "@/lib/integration-status";
 import { shouldInvalidateMailQueryForActionEvent } from "@/lib/sync-invalidation";
 import { TAB_ID } from "@/lib/tab-id";
-import { getThreadCacheOwner, setThreadCacheOwner } from "@/lib/thread-cache";
+import {
+  bindThreadCacheQueryClient,
+  getThreadCacheOwner,
+  setThreadCacheOwner,
+} from "@/lib/thread-cache";
 
 import { i18nCatalog } from "./i18n";
 
@@ -576,7 +580,11 @@ export function computeSessionBypass(): boolean {
 }
 
 export default function Root() {
-  const [queryClient] = useState(() => createAgentNativeQueryClient());
+  const [queryClient] = useState(() => {
+    const client = createAgentNativeQueryClient();
+    bindThreadCacheQueryClient(client);
+    return client;
+  });
   return (
     <AppToolkitProvider>
       <AppProviders

package/corpus/templates/mail/changelog/2026-10-20-connected-gong-settings-now-open-the-shared-integration-mana.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-20
+---
+
+Connected Gong settings now open the shared integration manager.

package/corpus/templates/mail/changelog/2026-10-20-gong-connection-details-now-match-the-call-data-available-in.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-20
+---
+
+Gong connection details now match the call data available in Mail.

package/corpus/templates/mail/changelog/2026-10-20-improve-gong-setup-with-a-click-to-connect-flow-and-permissi.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-20
+---
+
+Improve Gong setup with a click-to-connect flow and permission gating

package/corpus/templates/mail/changelog/2026-10-20-mail-lets-you-retry-when-it-cannot-check-your-gong-access.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-20
+---
+
+Mail lets you retry when it cannot check your Gong access.

package/corpus/templates/mail/changelog/2026-10-20-mail-thread-cache-stays-isolated-when-mailbox-scope-changes.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-20
+---
+
+Cached conversations stay with the mailbox they belong to.

package/corpus/templates/mail/changelog/2026-10-20-the-inbox-and-recently-opened-threads-now-open-instantly-fro.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-10-20
+---
+
+The inbox and recently opened threads now open instantly from a cache on your device, cleared when you sign out, then refresh in the background.

package/corpus/templates/mail/server/handlers/emails.ts

@@ -7,6 +7,10 @@ import {
 import { readBody, getSession } from "@agent-native/core/server";
 import { getAppProductionUrl } from "@agent-native/core/server";
 import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
+import {
+  ACTION_BROWSER_PERSIST_ALLOW,
+  ACTION_BROWSER_PERSIST_HEADER,
+} from "@agent-native/core/shared";
 import {
   gmailReadState,
   GMAIL_QUOTA_COOLDOWN_ERROR_CODE,
@@ -800,6 +804,11 @@ export const listEmails = defineEventHandler(async (event: H3Event) => {
 // ─── Thread messages ─────────────────────────────────────────────────────────
 
 export const getThreadMessages = defineEventHandler(async (event: H3Event) => {
+  setResponseHeader(
+    event,
+    ACTION_BROWSER_PERSIST_HEADER,
+    ACTION_BROWSER_PERSIST_ALLOW,
+  );
   const email = await userEmail(event);
   const threadId = getRouterParam(event, "threadId") as string;
   const { accountEmail } = getQuery(event) as { accountEmail?: string };

package/corpus/templates/plan/.agents/skills/actions/references/action-fields.md

@@ -95,9 +95,9 @@ MCP clients see no `outputSchema` by default. Set `mcpOutputSchema: true` (requi
 
 `authorize` decides whether the caller may run the action at all. It wraps
 `run`, so it holds at **all six dispatch sites** — agent tool, HTTP, frontend
-hook, MCP, A2A, CLI — unlike `needsApproval`, which is honoured only in the
-agent loop. Use `authorize` for "not everyone may do this"; use `needsApproval`
-to ask a human to bless one call a permitted caller is already allowed to make.
+hook, MCP, A2A, CLI. Use `authorize` for "not everyone may do this"; use
+`needsApproval` to ask a human to bless one call a permitted caller is already
+allowed to make.
 
 ```ts
 import { coachAccess } from "../lib/access.js"; // defineAppRoles(...)
@@ -140,4 +140,6 @@ export default defineAction({
 
 When the gate is truthy and the call isn't yet approved, the loop emits an `approval_required` event and **stops the turn — `run()` never executes**. A predicate gates conditionally (e.g. only external recipients) and **fails closed**: a throw is treated as "approval required". It receives its own copy of the prepared snapshot of the validated arguments, defaults applied, and the approval binds to the snapshot's hash, so an approved call runs only with the arguments that were approved (a Date binds by its time). The human approves via the chat UI's Approve affordance, which re-issues the turn with the call's `approvalKey`, and only then does the action run.
 
+Approval is given in the app, so HTTP never grants it. The HTTP action route and the generated Workers entry run a gated call only for the proven app UI (a frontend call from the signed-in user, same origin, holding the short-lived UI capability; `isProvenUiRequest`, the proof `uiOnly` uses) or the app's MCP directory widget. Every other HTTP caller (bearer or API key, MCP OAuth token, org service token, A2A, extension iframe, mobile app) gets `409 approval_required`, and a service identity can never approve. The shared client presents the capability with every write from a signed-in session (minted once per user, reused for nine minutes, never for reads or public pages), so a gated button works on its first request. A call without proof gets `403 ui_capability_required`; the client then re-mints and retries once, which is only the fallback for an expired or rejected capability. Every surface evaluates the gate through `preparedCallNeedsApproval`, so a throwing predicate asks there too. A caller that must run unattended needs a different action, never a bypass of the gate.
+
 **Keep approvals rare** — the default is off and almost every action should leave it off. The canonical example is Mail's `send-email` (`needsApproval: true`). See the `security` skill and the Human Approval doc.

package/corpus/templates/plan/CHANGELOG.md

@@ -5,6 +5,10 @@ time from the command menu (Cmd+K → "What's new").
 
 ## 2026-10-19
 
+### Fixed
+
+- Opening a comment thread puts the cursor in the reply box, and Edit puts it after the comment's text. A reply you haven't sent stays with its thread when you open another one.
+
 ### Changed
 
 - Apps no longer keep server functions and databases warm by default; set `AGENT_NATIVE_ENABLE_KEEP_WARM=1` to opt in.