@agent-native/core 0.167.0 → 0.167.4

package/dist/client/use-chat-threads.js

@@ -3,12 +3,13 @@ import { agentNativePath } from "./api-path.js";
 const ACTIVE_THREAD_KEY = "agent-chat-active-thread";
 const THREADS_UPDATED_EVENT = "agent-chat:threads-updated";
 const THREADS_PAGE_SIZE = 50;
-async function fetchThreadListPage(apiUrl, offset, includeExternal) {
+async function fetchThreadListPage(apiUrl, offset, includeExternal, scope) {
     const params = new URLSearchParams();
     if (offset > 0)
         params.set("offset", String(offset));
     if (includeExternal)
         params.set("includeExternal", "1");
+    appendChatThreadScopeParams(params, scope);
     const query = params.toString();
     return fetch(`${apiUrl}/threads${query ? `?${query}` : ""}`).then(async (res) => {
         if (!res.ok)
@@ -22,9 +23,12 @@ async function fetchThreadListPage(apiUrl, offset, includeExternal) {
  * the caller must not collapse: the thread (found), `null` (the server denies it
  * exists), and `undefined` (unreachable — nothing was learned).
  */
-async function fetchThreadById(apiUrl, id) {
+async function fetchThreadById(apiUrl, id, scope) {
     try {
-        const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}`);
+        const params = new URLSearchParams();
+        appendChatThreadScopeParams(params, scope);
+        const query = params.toString();
+        const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}${query ? `?${query}` : ""}`);
         if (res.status === 404)
             return null;
         if (!res.ok)
@@ -35,6 +39,20 @@ async function fetchThreadById(apiUrl, id) {
         return undefined;
     }
 }
+export function appendChatThreadScopeParams(params, scope) {
+    if (!scope)
+        return;
+    params.set("scopeType", scope.type);
+    params.set("scopeId", scope.id);
+}
+function withChatThreadScope(url, scope) {
+    const params = new URLSearchParams();
+    appendChatThreadScopeParams(params, scope);
+    const query = params.toString();
+    if (!query)
+        return url;
+    return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+}
 function emitThreadsUpdated() {
     if (typeof window === "undefined")
         return;
@@ -91,6 +109,12 @@ function threadCanStayVisibleInScope(threadScope, currentScope) {
         return true;
     return scopesMatch(threadScope, currentScope);
 }
+function threadCanStayVisibleInHistory(threadScope, currentScope, isolateHistoryByScope = false) {
+    if (!isolateHistoryByScope) {
+        return threadCanStayVisibleInScope(threadScope, currentScope);
+    }
+    return scopesMatch(threadScope, currentScope);
+}
 function nextThreadTitle(currentTitle, incomingTitle, incomingPreview, source = "extracted", options = {}) {
     if (options.preserveUserTitle && currentTitle)
         return currentTitle;
@@ -109,6 +133,12 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     const autoCreate = options?.autoCreate !== false;
     const restoreActiveThread = options?.restoreActiveThread !== false;
     const includeExternal = options?.includeExternal === true;
+    const isolateHistoryByScope = options?.isolateHistoryByScope === true;
+    const isolateHistory = isolateHistoryByScope && Boolean(scope);
+    const historyScope = useMemo(() => (isolateHistory && scope ? { type: scope.type, id: scope.id } : null), [isolateHistory, scope?.id, scope?.type]);
+    const historyScopeKey = historyScope
+        ? `${historyScope.type}:${historyScope.id}`
+        : null;
     const routeControlsActiveThread = options?.routeThreadId !== undefined;
     const routeThreadId = normalizeThreadId(options?.routeThreadId);
     // Each (storageKey, scope) pair gets its own active-thread localStorage key
@@ -170,6 +200,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         ? new Set([initialActiveThreadRef.current.id])
         : new Set());
     const optimisticThreadScopesRef = useRef(new Map());
+    const knownThreadScopesRef = useRef(new Map());
     const pendingPinnedAtRef = useRef(new Map());
     const pendingArchivedAtRef = useRef(new Map());
     const userRenamedThreadIdsRef = useRef(new Set());
@@ -215,6 +246,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         if (optimisticThreadScopesRef.current.has(id)) {
             return optimisticThreadScopesRef.current.get(id) ?? null;
         }
+        if (knownThreadScopesRef.current.has(id)) {
+            return knownThreadScopesRef.current.get(id) ?? null;
+        }
         return undefined;
     }, []);
     // Add a client-generated thread to the local list optimistically.
@@ -290,7 +324,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 if (currentThreadScope === undefined) {
                     return;
                 }
-                if (threadCanStayVisibleInScope(currentThreadScope, scopeRef.current)) {
+                if (threadCanStayVisibleInHistory(currentThreadScope, scopeRef.current, isolateHistory)) {
                     persistedKeyRef.current = activeThreadKey;
                     return;
                 }
@@ -308,7 +342,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             if (nextActiveThreadId) {
                 const savedScope = readKnownThreadScope(nextActiveThreadId);
                 if (savedScope !== undefined &&
-                    !threadCanStayVisibleInScope(savedScope, scopeRef.current)) {
+                    !threadCanStayVisibleInHistory(savedScope, scopeRef.current, isolateHistory)) {
                     nextActiveThreadId = null;
                 }
             }
@@ -356,7 +390,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         const requestId = ++latestFetchRequestRef.current;
         try {
             const offset = options?.append ? nextThreadsOffsetRef.current : 0;
-            const loaded = await fetchThreadListPage(apiUrl, offset, includeExternal);
+            const loaded = await fetchThreadListPage(apiUrl, offset, includeExternal, historyScope);
             if (requestId !== latestFetchRequestRef.current)
                 return undefined;
             if (!loaded) {
@@ -365,6 +399,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 }
                 return;
             }
+            for (const thread of loaded) {
+                knownThreadScopesRef.current.set(thread.id, thread.scope ?? null);
+            }
             setThreadsLoadError(null);
             if (!options?.append) {
                 nextThreadsOffsetRef.current = loaded.length;
@@ -373,8 +410,11 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 nextThreadsOffsetRef.current += loaded.length;
             }
             setHasMoreThreads(loaded.length >= THREADS_PAGE_SIZE);
+            const visibleLoaded = isolateHistory
+                ? loaded.filter((thread) => threadCanStayVisibleInHistory(thread.scope, historyScope, isolateHistory))
+                : loaded;
             setThreads((prev) => {
-                const loadedIds = new Set(loaded.map((t) => t.id));
+                const loadedIds = new Set(visibleLoaded.map((t) => t.id));
                 // Preserve any optimistic threads we've created this session that
                 // haven't shown up in the server list yet — the server only learns
                 // about a thread when the user actually sends a message and the
@@ -387,13 +427,15 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 // and get preserved forever instead of disappearing once archived.
                 const optimisticOnly = prev.filter((t) => newlyCreatedRef.current.has(t.id) &&
                     !loadedIds.has(t.id) &&
-                    !t.archivedAt);
+                    !t.archivedAt &&
+                    (!isolateHistory ||
+                        threadCanStayVisibleInHistory(t.scope, historyScope, isolateHistory)));
                 // Reconcile each server thread against our local copy. If the local
                 // copy has a newer updatedAt or higher messageCount, keep those
                 // fields — the server probably hasn't observed the user's latest
                 // send yet, and naively replacing makes the recent-chats list
                 // visibly jump back to older timestamps right after a send.
-                const merged = loaded.map((server) => {
+                const merged = visibleLoaded.map((server) => {
                     const local = prev.find((t) => t.id === server.id);
                     if (!local)
                         return server;
@@ -438,7 +480,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 }
                 return [...optimisticOnly, ...merged];
             });
-            return loaded;
+            return visibleLoaded;
         }
         catch {
             if (requestId !== latestFetchRequestRef.current)
@@ -448,7 +490,28 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             }
             return undefined;
         }
-    }, [apiUrl, includeExternal]);
+    }, [apiUrl, historyScope, includeExternal, isolateHistory]);
+    const loadedHistoryScopeKeyRef = useRef(historyScopeKey);
+    useEffect(() => {
+        if (loadedHistoryScopeKeyRef.current === historyScopeKey)
+            return;
+        loadedHistoryScopeKeyRef.current = historyScopeKey;
+        if (!isolateHistoryByScope)
+            return;
+        nextThreadsOffsetRef.current = 0;
+        setHasMoreThreads(false);
+        setThreadsLoadError(null);
+        setThreads((prev) => prev.filter((thread) => !isolateHistory ||
+            threadCanStayVisibleInHistory(thread.scope, historyScope, isolateHistory)));
+        setIsLoading(true);
+        void fetchThreads().finally(() => setIsLoading(false));
+    }, [
+        fetchThreads,
+        historyScope,
+        historyScopeKey,
+        isolateHistory,
+        isolateHistoryByScope,
+    ]);
     const loadMoreThreads = useCallback(async () => {
         if (isLoadingMoreThreads || !hasMoreThreads)
             return;
@@ -509,8 +572,11 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             // One page, so absence from it is not absence from the server — this is what
             // separates an older real thread from an unavailable saved id below.
             const restoredThread = lookupRestored && !restoredOnPage
-                ? await fetchThreadById(apiUrl, restoredId)
+                ? await fetchThreadById(apiUrl, restoredId, historyScope)
                 : restoredOnPage;
+            if (restoredThread) {
+                knownThreadScopesRef.current.set(restoredThread.id, restoredThread.scope ?? null);
+            }
             if (restoredThread === undefined && lookupRestored && !restoredOnPage) {
                 // Lookup unreachable. Reclassifying now would stamp this thread with the
                 // current scope on a guess; leave it untouched for the next mount.
@@ -519,7 +585,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             }
             const restoredIsUnavailable = restoredThread === null && lookupRestored && !restoredOnPage;
             const restoredBelongsElsewhere = Boolean(restoredThread &&
-                !threadCanStayVisibleInScope(restoredThread.scope ?? null, scopeRef.current));
+                !threadCanStayVisibleInHistory(restoredThread.scope ?? null, scopeRef.current, isolateHistory));
             // A missing saved id is stale local UI state on a normal home surface,
             // not a reason to show an error above a fresh composer. Preserve it for
             // explicit routes and list-only readers, where the caller still owns
@@ -587,6 +653,8 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         fetchThreads,
         addOptimisticThread,
         autoCreate,
+        historyScope,
+        isolateHistory,
         routeControlsActiveThread,
         routeThreadId,
     ]);
@@ -641,7 +709,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     // list right away.
     const detachThread = useCallback(async (threadId) => {
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}`, {
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}`, historyScope), {
                 method: "PUT",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ scope: null }),
@@ -652,14 +720,42 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 await fetchThreads();
                 return;
             }
-            setThreads((prev) => prev.map((t) => (t.id === threadId ? { ...t, scope: null } : t)));
+            knownThreadScopesRef.current.set(threadId, null);
             optimisticThreadScopesRef.current.set(threadId, null);
+            const wasActive = activeThreadIdRef.current === threadId;
+            if (isolateHistory) {
+                setThreads((prev) => prev.filter((thread) => thread.id !== threadId &&
+                    threadCanStayVisibleInHistory(thread.scope, historyScope, isolateHistory)));
+                if (wasActive) {
+                    const remaining = threadsRef.current.filter((thread) => thread.id !== threadId &&
+                        threadCanStayVisibleInHistory(thread.scope, historyScope, isolateHistory));
+                    if (remaining.length > 0) {
+                        setActiveThreadId(remaining[0].id);
+                    }
+                    else if (autoCreate) {
+                        void createThread();
+                    }
+                    else {
+                        setActiveThreadId(null);
+                    }
+                }
+            }
+            else {
+                setThreads((prev) => prev.map((t) => (t.id === threadId ? { ...t, scope: null } : t)));
+            }
             emitThreadsUpdated();
         }
         catch {
             await fetchThreads().catch(() => { });
         }
-    }, [apiUrl, fetchThreads]);
+    }, [
+        apiUrl,
+        autoCreate,
+        createThread,
+        fetchThreads,
+        historyScope,
+        isolateHistory,
+    ]);
     const pinThread = useCallback(async (threadId, pinned) => {
         const previousPinnedAt = threadsRef.current.find((t) => t.id === threadId)?.pinnedAt ?? null;
         const previousUpdatedAt = threadsRef.current.find((t) => t.id === threadId)?.updatedAt ?? null;
@@ -680,7 +776,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         };
         setThreads((prev) => prev.map((t) => (t.id === threadId ? { ...t, pinnedAt } : t)));
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}/pin`, {
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/pin`, historyScope), {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ pinned }),
@@ -701,7 +797,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             await fetchThreads();
             return false;
         }
-    }, [apiUrl, fetchThreads]);
+    }, [apiUrl, fetchThreads, historyScope]);
     const archiveThread = useCallback(async (threadId) => {
         const previousArchivedAt = threadsRef.current.find((t) => t.id === threadId)?.archivedAt ?? null;
         const previousUpdatedAt = threadsRef.current.find((t) => t.id === threadId)?.updatedAt ?? null;
@@ -726,7 +822,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         };
         setThreads((prev) => prev.map((t) => (t.id === threadId ? { ...t, archivedAt } : t)));
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}/archive`, {
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/archive`, historyScope), {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ archived: true }),
@@ -750,7 +846,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             await fetchThreads();
             return false;
         }
-    }, [apiUrl, fetchThreads]);
+    }, [apiUrl, fetchThreads, historyScope]);
     const renameThread = useCallback(async (threadId, title) => {
         const nextTitle = title.replace(/\s+/g, " ").trim().slice(0, 160);
         if (!nextTitle)
@@ -768,7 +864,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         markUserRenamedThread(threadId);
         setThreads((prev) => prev.map((t) => (t.id === threadId ? { ...t, title: nextTitle } : t)));
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}/rename`, {
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/rename`, historyScope), {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ title: nextTitle }),
@@ -786,7 +882,13 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             await fetchThreads();
             return false;
         }
-    }, [apiUrl, clearUserRenamedThread, fetchThreads, markUserRenamedThread]);
+    }, [
+        apiUrl,
+        clearUserRenamedThread,
+        fetchThreads,
+        historyScope,
+        markUserRenamedThread,
+    ]);
     const isNewThread = useCallback((id) => newlyCreatedRef.current.has(id), []);
     const switchThread = useCallback((id) => {
         persistActiveThreadId(id);
@@ -794,7 +896,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     }, [persistActiveThreadId]);
     const removeThread = useCallback(async (id) => {
         try {
-            await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}`, {
+            await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(id)}`, historyScope), {
                 method: "DELETE",
             });
             emitThreadsUpdated();
@@ -816,7 +918,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 createThread();
             }
         }
-    }, [apiUrl, clearUserRenamedThread, createThread]);
+    }, [apiUrl, clearUserRenamedThread, createThread, historyScope]);
     // Reads scope through refs so this callback survives every setThreads. Scope
     // rides only on creation: a periodic save must never move an existing thread
     // between resources, however stale this client's guess is.
@@ -828,7 +930,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const preserveUserTitle = userRenamedThreadIdsRef.current.has(id);
             const title = nextThreadTitle(localThread?.title, data.title, data.preview, titleSource, { preserveUserTitle });
             const payload = { ...threadDataPayload, title };
-            let response = await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}`, {
+            let response = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(id)}`, historyScope), {
                 method: "PUT",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(payload),
@@ -837,7 +939,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             // client-created thread, so no agent run has created its SQL row yet.
             // Materialize that row idempotently and retry the same full save.
             if (response.status === 404) {
-                const created = await fetch(`${apiUrl}/threads`, {
+                const created = await fetch(withChatThreadScope(`${apiUrl}/threads`, historyScope), {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify({
@@ -848,7 +950,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 });
                 if (!created.ok)
                     return;
-                response = await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}`, {
+                response = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(id)}`, historyScope), {
                     method: "PUT",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify(payload),
@@ -894,7 +996,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             });
         }
         catch { }
-    }, [apiUrl, readKnownThreadScope]);
+    }, [apiUrl, historyScope, readKnownThreadScope]);
     const generateTitle = useCallback(async (threadId, message) => {
         try {
             const res = await fetch(`${apiUrl}/generate-title`, {
@@ -923,7 +1025,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         const fallbackForkFromSnapshot = async (source) => {
             const title = source.title ? `${source.title} (fork)` : "";
             const createdAt = Date.now();
-            const createRes = await fetch(`${apiUrl}/threads`, {
+            const createRes = await fetch(withChatThreadScope(`${apiUrl}/threads`, historyScope), {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({
@@ -934,7 +1036,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             });
             if (!createRes.ok)
                 return null;
-            const saveRes = await fetch(`${apiUrl}/threads/${encodeURIComponent(id)}`, {
+            const saveRes = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(id)}`, historyScope), {
                 method: "PUT",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({
@@ -962,7 +1064,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const source = sourceSnapshot && sourceSnapshot.messageCount > 0
                 ? { ...sourceSnapshot, scope: localScope }
                 : undefined;
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(sourceId)}/fork`, {
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(sourceId)}/fork`, historyScope), {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ id, ...(source ? { source } : {}) }),
@@ -1003,25 +1105,27 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             console.error(`[chat] fork threw for ${sourceId}:`, err);
             return null;
         }
-    }, [apiUrl]);
+    }, [apiUrl, historyScope]);
     const searchThreads = useCallback(async (query) => {
         try {
             const params = new URLSearchParams({ q: query });
             if (includeExternal)
                 params.set("includeExternal", "1");
+            appendChatThreadScopeParams(params, historyScope);
             const res = await fetch(`${apiUrl}/threads?${params.toString()}`);
             if (!res.ok)
                 return [];
             const data = await res.json();
-            return data.threads ?? [];
+            return (data.threads ?? []).filter((thread) => !isolateHistory ||
+                threadCanStayVisibleInHistory(thread.scope, historyScope, isolateHistory));
         }
         catch {
             return [];
         }
-    }, [apiUrl, includeExternal]);
+    }, [apiUrl, historyScope, includeExternal, isolateHistory]);
     const getThreadShareState = useCallback(async (threadId) => {
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`);
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, historyScope));
             if (!res.ok)
                 return null;
             const data = await res.json();
@@ -1030,10 +1134,10 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         catch {
             return null;
         }
-    }, [apiUrl]);
+    }, [apiUrl, historyScope]);
     const createThreadShareLink = useCallback(async (threadId) => {
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, { method: "POST" });
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, historyScope), { method: "POST" });
             if (!res.ok)
                 return null;
             const data = await res.json();
@@ -1044,10 +1148,10 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         catch {
             return null;
         }
-    }, [apiUrl]);
+    }, [apiUrl, historyScope]);
     const revokeThreadShareLink = useCallback(async (threadId) => {
         try {
-            const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, { method: "DELETE" });
+            const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, historyScope), { method: "DELETE" });
             if (!res.ok)
                 return null;
             const data = await res.json();
@@ -1056,7 +1160,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         catch {
             return null;
         }
-    }, [apiUrl]);
+    }, [apiUrl, historyScope]);
     const refreshThreads = useCallback(() => {
         fetchThreads();
     }, [fetchThreads]);

package/dist/deploy/build.d.ts

@@ -101,6 +101,11 @@ export declare function isDurableBackgroundDeployEnabled(): boolean;
 export declare const NETLIFY_INTEGRATION_RECOVERY_FUNCTION_NAME = "server-integration-recovery";
 export declare function isIntegrationDurableDispatchDeployEnabled(): boolean;
 export declare const NETLIFY_RECURRING_JOBS_FUNCTION_NAME = "agent-native-recurring-jobs";
+/**
+ * Routed through the same resolver that produces the runtime marker, so the gate
+ * that emits the scheduled function and the value the deployed app reports
+ * cannot drift: a build that skips the emit always ships `"disabled"`.
+ */
 export declare function isRecurringJobsDeployEnabled(): boolean;
 /**
  * Keep-warm is opt-in because a once-a-minute wake prevents autosuspend on

package/dist/deploy/build.js

@@ -24,6 +24,7 @@ import { INTEGRATION_RECOVERY_RUNTIME_MARKER, INTEGRATION_RETRY_SWEEP_PATH, INTE
 import { isValidCron } from "../jobs/cron.js";
 import { RECURRING_JOBS_SWEEP_PATH, RECURRING_JOBS_SWEEP_TOKEN_SUBJECT, } from "../jobs/scheduler-dispatch.js";
 import { findWorkspaceRoot as findAgentNativeWorkspaceRoot } from "../scripts/utils.js";
+import { RECURRING_JOBS_BUILD_MARKER_ENV_VAR, resolveRecurringJobsBuildMarker, } from "../server/agent-chat/recurring-jobs-runtime.js";
 import { normalizeAppBasePath } from "../server/app-base-path.js";
 import { DEFAULT_SPECULATION_RULES_PATH, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
@@ -2407,8 +2408,13 @@ function isTruthyEnv(name) {
 function isDisabledByEnv(name) {
     return isTruthyEnv(name);
 }
+/**
+ * Routed through the same resolver that produces the runtime marker, so the gate
+ * that emits the scheduled function and the value the deployed app reports
+ * cannot drift: a build that skips the emit always ships `"disabled"`.
+ */
 export function isRecurringJobsDeployEnabled() {
-    return !isDisabledByEnv("AGENT_NATIVE_DISABLE_RECURRING_JOBS");
+    return resolveRecurringJobsBuildMarker(process.env) === "enabled";
 }
 /**
  * Keep-warm is opt-in because a once-a-minute wake prevents autosuspend on
@@ -3887,6 +3893,11 @@ export function resolveNitroBuildReplacements(env = process.env, deploymentEnvir
         // well as in the Vite server bundle.
         "process.env.AGENT_NATIVE_RELEASE_MIGRATIONS": JSON.stringify(env.AGENT_NATIVE_RELEASE_MIGRATIONS?.trim() || ""),
         "process.env.AGENT_NATIVE_BUILD_DEPLOY_CONTEXT": JSON.stringify(env.CONTEXT?.trim() || env.NETLIFY_CONTEXT?.trim() || ""),
+        // Whether the recurring-jobs scheduled function exists is decided HERE, by
+        // the build env. `scheduledTriggerAvailability` cannot re-derive it later —
+        // a pipeline that sets the kill switch only for the build leaves no runtime
+        // trace of it — so hand the decision to the runtime explicitly.
+        [`process.env.${RECURRING_JOBS_BUILD_MARKER_ENV_VAR}`]: JSON.stringify(resolveRecurringJobsBuildMarker(env)),
         ...(configuredDeploymentEnvironment
             ? {
                 "process.env.AGENT_NATIVE_DEPLOYMENT_ENVIRONMENT": JSON.stringify(configuredDeploymentEnvironment),

package/dist/framework-tools.js

@@ -126,6 +126,7 @@ export const CORE_ACTION_GROUPS = {
     "manage-recurring-job": "automation",
     "run-automation-now": "automation",
     "list-automation-runs": "automation",
+    "get-scheduled-trigger-status": "automation",
     "list-automations": "automation",
     "manage-automation": "automation",
     "get-usage-alerts": "automation",

package/dist/jobs/actions/get-scheduled-trigger-status.d.ts

@@ -0,0 +1,13 @@
+import { type ScheduledTriggerAvailability } from "../../server/agent-chat/recurring-jobs-runtime.js";
+export type ScheduledTriggerStatus = ScheduledTriggerAvailability;
+/**
+ * Read surface for "will a schedule-triggered automation actually fire here".
+ *
+ * A separate action rather than a field on `list-automations` / `list-recurring-jobs`:
+ * both of those return bare arrays that several callers map over directly, so
+ * adding a sibling field means an envelope and a breaking change at every call
+ * site. This is deploy-scoped rather than per-automation data anyway — it never
+ * varies by row — so it caches independently and for much longer.
+ */
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, ScheduledTriggerAvailability>;
+export default _default;

package/dist/jobs/actions/get-scheduled-trigger-status.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { scheduledTriggerAvailability, } from "../../server/agent-chat/recurring-jobs-runtime.js";
+/**
+ * Read surface for "will a schedule-triggered automation actually fire here".
+ *
+ * A separate action rather than a field on `list-automations` / `list-recurring-jobs`:
+ * both of those return bare arrays that several callers map over directly, so
+ * adding a sibling field means an envelope and a breaking change at every call
+ * site. This is deploy-scoped rather than per-automation data anyway — it never
+ * varies by row — so it caches independently and for much longer.
+ */
+export default defineAction({
+    description: "Report whether schedule-triggered automations can actually fire in this deploy, and which driver (or missing driver) decides that. Used by the Agent Automations page to warn that a schedule will never run.",
+    agentTool: false,
+    schema: z.object({}),
+    http: { method: "GET" },
+    readOnly: true,
+    parallelSafe: true,
+    run: async () => scheduledTriggerAvailability(),
+});

package/dist/localization/default-messages.d.ts

@@ -667,6 +667,20 @@ declare const messages: {
         organization: string;
         settingsSummary: string;
         openAutomations: string;
+        nextRunNeverScheduler: string;
+        nextRunSchedulerUnknown: string;
+        nextRunSchedulerUnknownNoDate: string;
+        scheduleUnknownTitle: string;
+        scheduleUnknownDetail: string;
+        scheduleUnavailableTitle: string;
+        scheduleUnavailableLocalTitle: string;
+        scheduleUnavailableDisabled: string;
+        scheduleUnavailableNoScheduler: string;
+        scheduleUnavailableLocal: string;
+        scheduleUnavailableDisabledFix: string;
+        scheduleUnavailableLocalFix: string;
+        scheduleUnavailableFixLabel: string;
+        scheduleUnavailableFixLabelOpen: string;
     };
     share: {
         titleWithResource: string;

package/dist/localization/default-messages.js

@@ -673,6 +673,20 @@ const messages = {
         organization: "Organization",
         settingsSummary: "Manage scheduled and event-triggered agent tasks together from the Automations page.",
         openAutomations: "Open Automations",
+        nextRunNeverScheduler: "Never — no scheduler in this deploy",
+        nextRunSchedulerUnknown: "{{date}} — unconfirmed, the scheduler check failed",
+        nextRunSchedulerUnknownNoDate: "Unknown — the scheduler check failed",
+        scheduleUnknownTitle: "Couldn't check whether schedules run here",
+        scheduleUnknownDetail: "The scheduler status check failed, so the next run times below are unconfirmed. Reload to check again.",
+        scheduleUnavailableTitle: "Schedules won't run in this deploy",
+        scheduleUnavailableLocalTitle: "Schedules don't run in local development",
+        scheduleUnavailableDisabled: "This app was built with recurring jobs turned off, so no scheduled automation will fire. Event-triggered automations and Run now still work.",
+        scheduleUnavailableNoScheduler: "This hosting target has no durable scheduler, so no scheduled automation will fire. Event-triggered automations and Run now still work.",
+        scheduleUnavailableLocal: "Schedules stay off on a dev machine unless you opt in. Event-triggered automations and Run now still work.",
+        scheduleUnavailableDisabledFix: "To enable recurring jobs, set AGENT_NATIVE_DISABLE_RECURRING_JOBS=false in the build environment.",
+        scheduleUnavailableLocalFix: "Set AGENT_NATIVE_ENABLE_LOCAL_RECURRING_JOBS=true to run schedules on this machine.",
+        scheduleUnavailableFixLabel: "Show more",
+        scheduleUnavailableFixLabelOpen: "Show less",
     },
     share: {
         titleWithResource: 'Share "{{title}}"',