@agent-native/core 0.146.8 → 0.147.0

package/dist/client/extensions/ExtensionViewer.js

@@ -7,6 +7,7 @@ import { buildExtensionHtml } from "../../extensions/html-shell.js";
 import { extensionPath, isExtensionPathname } from "../../extensions/path.js";
 import { getThemeVars } from "../../extensions/theme.js";
 import { SESSION_REPLAY_IFRAME_ATTRIBUTE } from "../../session-replay-iframe-protocol.js";
+import { normalizeDocumentTitle } from "../../shared/document-title.js";
 import { sendToAgentChat } from "../agent-chat.js";
 import { AgentToggleButton } from "../AgentPanel.js";
 import { agentNativePath, appPath } from "../api-path.js";
@@ -68,7 +69,13 @@ function readExtensionTitleSuffix() {
     return match?.[1]?.trim() || null;
 }
 function extensionDocumentTitle(name, suffix) {
-    return suffix ? `${name} \u2014 ${suffix}` : `${name} \u2014 Extensions`;
+    const safeName = normalizeDocumentTitle(name, "Untitled extension");
+    const safeSuffix = suffix
+        ? normalizeDocumentTitle(suffix, "Extensions")
+        : null;
+    return safeSuffix
+        ? `${safeName} \u2014 ${safeSuffix}`
+        : `${safeName} \u2014 Extensions`;
 }
 function extensionRole(value) {
     return value === "owner" ||

package/dist/client/resources/McpIntegrationDialog.js

@@ -9,7 +9,7 @@ import { useT } from "../i18n.js";
 import { cn } from "../utils.js";
 import { buildMcpOAuthStartUrl, createMcpIntegrationFormDefaults, filterMcpIntegrations, getMcpIntegrationApiFallback, getDefaultMcpIntegrations, isCustomMcpIntegrationEnabled, navigateToMcpOAuthStart, resolveMcpIntegrationScope, shouldOfferMcpIntegrationOrganizationScope, shouldOfferMcpOrganizationScope, } from "./mcp-integration-catalog.js";
 import { McpIntegrationLogo } from "./McpIntegrationLogo.js";
-import { formatMcpServerError, getMcpUrlValidationError, testMcpServerUrl, useMcpServers, } from "./use-mcp-servers.js";
+import { formatMcpServerError, getMcpUrlValidationError, useMcpServersApi, useMcpServers, } from "./use-mcp-servers.js";
 function parseHeaderLines(text) {
     const out = {};
     for (const line of text.split(/\r?\n/)) {
@@ -64,6 +64,7 @@ export function McpIntegrationDialog({ open, onOpenChange, initialIntegrationId
     const [error, setError] = useState(null);
     const [testResult, setTestResult] = useState(null);
     const inputRef = useRef(null);
+    const mcpApi = useMcpServersApi();
     const mcpServersQuery = useMcpServers();
     const defaultIntegrations = useMemo(() => integrations ?? getDefaultMcpIntegrations(), [integrations]);
     const customIntegrationEnabled = useMemo(() => isCustomMcpIntegrationEnabled(), []);
@@ -250,7 +251,7 @@ export function McpIntegrationDialog({ open, onOpenChange, initialIntegrationId
         setError(null);
         setTestResult(null);
         try {
-            const res = await testMcpServerUrl(trimmedUrl, parseHeaderLines(headersText));
+            const res = await mcpApi.test(trimmedUrl, parseHeaderLines(headersText));
             setTestResult(res.ok
                 ? {
                     ok: true,

package/dist/client/resources/McpServerDetail.js

@@ -9,9 +9,10 @@ import { IconPlugConnected, IconAlertTriangle, IconLoader2, IconCheck, IconTestP
  * delete and recreate if they need to change a URL or headers.
  */
 import { useState } from "react";
-import { agentNativePath } from "../api-path.js";
 import { cn } from "../utils.js";
+import { useMcpServersApi, } from "./use-mcp-servers.js";
 export function McpServerDetail({ server }) {
+    const mcpApi = useMcpServersApi();
     const [testing, setTesting] = useState(false);
     const [testResult, setTestResult] = useState(null);
     const headers = server.headers ? Object.keys(server.headers) : [];
@@ -19,17 +20,11 @@ export function McpServerDetail({ server }) {
         setTesting(true);
         setTestResult(null);
         try {
-            // We don't have the real header values client-side (redacted). The
-            // test-existing endpoint uses the stored headers, but there's no
-            // convenient way to hit it from here without the server id + scope,
-            // which we do have — so wire that up.
-            const res = await fetch(agentNativePath(`/_agent-native/mcp/servers/${encodeURIComponent(server.id)}/test?scope=${server.scope}`), {
-                method: "POST",
-                credentials: "include",
-                headers: { "Content-Type": "application/json" },
+            const result = await mcpApi.testExisting({
+                id: server.id,
+                scope: server.scope,
             });
-            const body = (await res.json().catch(() => ({})));
-            setTestResult(body.ok ? body : { ok: false, error: body.error });
+            setTestResult(result.ok ? result : { ok: false, error: result.error });
         }
         catch (err) {
             setTestResult({ ok: false, error: err?.message ?? String(err) });

package/dist/client/resources/index.d.ts

@@ -7,3 +7,4 @@ export * from "./use-builtin-capabilities.js";
 export { DEFAULT_MCP_INTEGRATIONS, filterMcpIntegrations, findMcpIntegrationForText, getDefaultMcpIntegrations, isCustomMcpIntegrationEnabled, isMcpIntegrationCatalogAvailable, mergeDefaultMcpIntegrations, type DefaultMcpIntegration, } from "./mcp-integration-catalog.js";
 export { McpIntegrationDialog, type McpIntegrationDialogProps, } from "./McpIntegrationDialog.js";
 export { McpConnectionSuggestion, type McpConnectionSuggestionProps, type McpConnectionSuggestionVariant, } from "./McpConnectionSuggestion.js";
+export { McpServersApiProvider, useMcpServersApi, useMcpServers, useCreateMcpServer, useDeleteMcpServer, useReconnectMcpServer, testMcpServerUrl, type CreateMcpServerArgs, type McpServer, type McpServerScope, type McpServersApi, type McpServersList, type ReconnectMcpServerArgs, type TestMcpUrlResult, } from "./use-mcp-servers.js";

package/dist/client/resources/index.js

@@ -7,3 +7,4 @@ export * from "./use-builtin-capabilities.js";
 export { DEFAULT_MCP_INTEGRATIONS, filterMcpIntegrations, findMcpIntegrationForText, getDefaultMcpIntegrations, isCustomMcpIntegrationEnabled, isMcpIntegrationCatalogAvailable, mergeDefaultMcpIntegrations, } from "./mcp-integration-catalog.js";
 export { McpIntegrationDialog, } from "./McpIntegrationDialog.js";
 export { McpConnectionSuggestion, } from "./McpConnectionSuggestion.js";
+export { McpServersApiProvider, useMcpServersApi, useMcpServers, useCreateMcpServer, useDeleteMcpServer, useReconnectMcpServer, testMcpServerUrl, } from "./use-mcp-servers.js";

package/dist/client/resources/use-mcp-servers.d.ts

@@ -7,6 +7,7 @@
  * endpoints so the Workspace UI can list, create, and delete them with the
  * same keys/invalidations the old Settings panel used.
  */
+import { type ReactNode } from "react";
 export type McpServerScope = "user" | "org";
 export interface McpServer {
     id: string;
@@ -37,6 +38,25 @@ export interface McpServersList {
     orgId: string | null;
     role: string | null;
 }
+export interface McpServersApi {
+    list: () => Promise<McpServersList>;
+    create: (args: CreateMcpServerArgs) => Promise<McpServer>;
+    delete: (args: {
+        id: string;
+        scope: McpServerScope;
+    }) => Promise<void>;
+    reconnect: (args: ReconnectMcpServerArgs) => Promise<void>;
+    test: (url: string, headers?: Record<string, string>) => Promise<TestMcpUrlResult>;
+    testExisting: (args: {
+        id: string;
+        scope: McpServerScope;
+    }) => Promise<TestMcpUrlResult>;
+}
+export declare function McpServersApiProvider({ api, children, }: {
+    api: McpServersApi;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<McpServersApi | null>>;
+export declare function useMcpServersApi(): McpServersApi;
 export declare function useMcpServers(): import("@tanstack/react-query").UseQueryResult<NoInfer<McpServersList>, Error>;
 export interface CreateMcpServerArgs {
     scope: McpServerScope;

package/dist/client/resources/use-mcp-servers.js

@@ -8,54 +8,104 @@
  * same keys/invalidations the old Settings panel used.
  */
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createContext, createElement, useContext, } from "react";
 import { agentNativePath } from "../api-path.js";
 const ENDPOINT = agentNativePath("/_agent-native/mcp/servers");
 const LIST_KEY = ["mcp-servers"];
+const McpServersApiContext = createContext(null);
+export function McpServersApiProvider({ api, children, }) {
+    return createElement(McpServersApiContext.Provider, { value: api }, children);
+}
+export function useMcpServersApi() {
+    return useContext(McpServersApiContext) ?? defaultMcpServersApi;
+}
+async function listMcpServers() {
+    const res = await fetch(ENDPOINT, { credentials: "include" });
+    if (!res.ok)
+        throw new Error(`Failed to load (${res.status})`);
+    return (await res.json());
+}
+async function createMcpServer(args) {
+    const res = await fetch(ENDPOINT, {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(args),
+    });
+    const body = (await res.json().catch((error) => {
+        throw new Error("MCP create returned invalid JSON.", { cause: error });
+    }));
+    if (!res.ok || !body.ok) {
+        throw new Error(body.error || `Create failed (${res.status})`);
+    }
+    return body.server;
+}
+async function deleteMcpServer(args) {
+    const res = await fetch(`${ENDPOINT}/${encodeURIComponent(args.id)}?scope=${args.scope}`, {
+        method: "DELETE",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+    });
+    const body = (await res.json().catch((error) => {
+        throw new Error("MCP delete returned invalid JSON.", { cause: error });
+    }));
+    if (!res.ok || !body.ok) {
+        throw new Error(body.error || `Delete failed (${res.status})`);
+    }
+}
+async function reconnectMcpServer(args) {
+    const res = await fetch(reconnectMcpServerUrl(args), {
+        method: "POST",
+        credentials: "include",
+    });
+    const body = await readMcpMutationBody(res);
+    const error = typeof body?.error === "string" && body.error.trim()
+        ? body.error.trim()
+        : undefined;
+    if (!res.ok || body?.ok !== true) {
+        throw new Error(error || `Reconnect failed (${res.status})`);
+    }
+}
+async function testExistingMcpServer(args) {
+    const res = await fetch(agentNativePath(`/_agent-native/mcp/servers/${encodeURIComponent(args.id)}/test?scope=${args.scope}`), {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+    });
+    const body = (await res.json().catch((error) => {
+        throw new Error("MCP test returned invalid JSON.", { cause: error });
+    }));
+    return res.ok ? body : { ok: false, error: body.error };
+}
+const defaultMcpServersApi = {
+    list: listMcpServers,
+    create: createMcpServer,
+    delete: deleteMcpServer,
+    reconnect: reconnectMcpServer,
+    test: testMcpServerUrl,
+    testExisting: testExistingMcpServer,
+};
 export function useMcpServers() {
+    const api = useMcpServersApi();
     return useQuery({
         queryKey: LIST_KEY,
-        queryFn: async () => {
-            const res = await fetch(ENDPOINT, { credentials: "include" });
-            if (!res.ok)
-                throw new Error(`Failed to load (${res.status})`);
-            return (await res.json());
-        },
+        queryFn: api.list,
         staleTime: 10_000,
     });
 }
 export function useCreateMcpServer() {
     const qc = useQueryClient();
+    const api = useMcpServersApi();
     return useMutation({
-        mutationFn: async (args) => {
-            const res = await fetch(ENDPOINT, {
-                method: "POST",
-                credentials: "include",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(args),
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (!res.ok || !body.ok) {
-                throw new Error(body.error || `Create failed (${res.status})`);
-            }
-            return body.server;
-        },
+        mutationFn: api.create,
         onSuccess: () => qc.invalidateQueries({ queryKey: LIST_KEY }),
     });
 }
 export function useDeleteMcpServer() {
     const qc = useQueryClient();
+    const api = useMcpServersApi();
     return useMutation({
-        mutationFn: async (args) => {
-            const res = await fetch(`${ENDPOINT}/${encodeURIComponent(args.id)}?scope=${args.scope}`, {
-                method: "DELETE",
-                credentials: "include",
-                headers: { "Content-Type": "application/json" },
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (!res.ok || !body.ok) {
-                throw new Error(body.error || `Delete failed (${res.status})`);
-            }
-        },
+        mutationFn: api.delete,
         onSuccess: () => qc.invalidateQueries({ queryKey: LIST_KEY }),
     });
 }
@@ -75,23 +125,9 @@ function reconnectMcpServerUrl(args) {
 }
 export function useReconnectMcpServer() {
     const qc = useQueryClient();
+    const api = useMcpServersApi();
     return useMutation({
-        mutationFn: async (args) => {
-            const res = await fetch(reconnectMcpServerUrl(args), {
-                method: "POST",
-                credentials: "include",
-            });
-            const body = await readMcpMutationBody(res);
-            const error = typeof body?.error === "string" && body.error.trim()
-                ? body.error.trim()
-                : undefined;
-            if (!res.ok) {
-                throw new Error(error || `Reconnect failed (${res.status})`);
-            }
-            if (body?.ok !== true) {
-                throw new Error(error || "Reconnect failed");
-            }
-        },
+        mutationFn: api.reconnect,
         onSuccess: () => qc.invalidateQueries({ queryKey: LIST_KEY }),
     });
 }

package/dist/client/settings/index.d.ts

@@ -5,5 +5,6 @@ export { AccountSettingsCard, AccountSettingsForm, type AccountSettingsCardProps
 export { openBuilderConnectPopup, useBuilderConnectFlow, useBuilderStatus, withBuilderConnectTrackingParams, type BuilderConnectFlow, type BuilderConnectFlowOptions, type BuilderConnectStartOptions, type BuilderStatus, type OpenBuilderConnectPopupOptions, } from "./useBuilderStatus.js";
 export { SecretsSection, type SecretsSectionProps } from "./SecretsSection.js";
 export { SettingsGroup, SettingsRow, type SettingsGroupProps, type SettingsRowProps, } from "./SettingsRow.js";
+export { SettingsSection, SettingsSurfaceProvider, useSettingsSurface, type SettingsSurface, } from "./SettingsSection.js";
 export { SettingsLoadingRow, SettingsSkeleton, type SettingsLoadingRowProps, type SettingsSkeletonProps, } from "./SettingsSkeleton.js";
 export { normalizeSettingsSection, settingsSectionDomId, useSettingsPanelController, type SettingsPanelController, type SettingsPanelControllerOptions, } from "./useSettingsPanelController.js";

package/dist/client/settings/index.js

@@ -5,5 +5,6 @@ export { AccountSettingsCard, AccountSettingsForm, } from "./AccountSettingsCard
 export { openBuilderConnectPopup, useBuilderConnectFlow, useBuilderStatus, withBuilderConnectTrackingParams, } from "./useBuilderStatus.js";
 export { SecretsSection } from "./SecretsSection.js";
 export { SettingsGroup, SettingsRow, } from "./SettingsRow.js";
+export { SettingsSection, SettingsSurfaceProvider, useSettingsSurface, } from "./SettingsSection.js";
 export { SettingsLoadingRow, SettingsSkeleton, } from "./SettingsSkeleton.js";
 export { normalizeSettingsSection, settingsSectionDomId, useSettingsPanelController, } from "./useSettingsPanelController.js";

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/jobs/background-automation-runner.js

@@ -1,4 +1,5 @@
 import { collectFinalResponseTextFromAgentEvents } from "../a2a/response-text.js";
+import { createBuilderEngine } from "../agent/engine/builder-engine.js";
 import { getStoredModelForEngine, normalizeModelForEngine, resolveEngine, } from "../agent/engine/index.js";
 import { actionsToEngineTools, filterInitialEngineTools, getOwnerActiveApiKey, } from "../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
@@ -9,6 +10,7 @@ import { resolveAutomationExecutionIdentity, } from "../automations/service.js";
 import { createThread } from "../chat-threads/store.js";
 import { queryOrgMembers } from "../org/context.js";
 import { organizationIdFromResourceOwner, organizationResourceOwner, } from "../resources/store.js";
+import { resolveBuilderCredentialsDetailed } from "../server/credential-provider.js";
 import { runWithRequestContext, } from "../server/request-context.js";
 import { attachAutomationRunThread, finishAutomationRun, startAutomationRun, } from "./run-history.js";
 const BACKGROUND_RUN_STUCK_MS = 10 * 60_000;
@@ -236,18 +238,33 @@ async function executeBackgroundAutomation(options, deps, historyId) {
         const availableTools = actionsToEngineTools(actions);
         const tools = filterInitialEngineTools(availableTools, initialToolNames);
         const userApiKey = await getOwnerActiveApiKey(ownerEmail);
-        const engine = deps.engine ??
+        const resolvedEngine = deps.engine ??
             (await resolveEngine({
                 apiKey: userApiKey ?? deps.apiKey,
                 appId: deps.appId,
             }));
+        // The run manager invokes its detached callback after the scheduler's
+        // setup stack has yielded. Capture the verified Builder pair while the
+        // owner/org identity is explicit, then keep it on the engine so a
+        // concurrent serverless run cannot make this call look unauthenticated.
+        const engine = !deps.engine && resolvedEngine.name === "builder"
+            ? createBuilderEngine({
+                credentials: await resolveBuilderCredentialsDetailed({
+                    userEmail: ownerEmail,
+                    orgId,
+                }),
+            })
+            : resolvedEngine;
         const modelCandidate = automation.meta.model ??
             deps.model ??
             (await getStoredModelForEngine(engine, { appId: deps.appId })) ??
             engine.defaultModel;
         const model = normalizeModelForEngine(engine, modelCandidate);
         const systemPrompt = await deps.getSystemPrompt(ownerEmail);
-        const thread = await createThread(ownerEmail, { title: threadTitle });
+        const thread = await createThread(ownerEmail, {
+            title: threadTitle,
+            orgId: orgId ?? null,
+        });
         const runId = createRunId(options.runIdPrefix);
         await recordRunThread(historyId, thread.id, runId);
         // Scheduled work is background work: it has no synchronous serverless

package/dist/jobs/scheduler-health.d.ts

@@ -1,4 +1,6 @@
 import { type MigrationEntry } from "../db/migrations.js";
+export declare const AUTOMATION_SCHEDULER_LEASE_MS: number;
+export declare const AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS = 60000;
 /** Authoritative release-time schema for recurring scheduler health. */
 export declare const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS: MigrationEntry[];
 export declare function runAutomationSchedulerHealthMigrations(nitroApp: unknown): Promise<void>;
@@ -11,6 +13,24 @@ export interface AutomationSchedulerHealth {
     runtime: string | null;
     updatedAt: number | null;
 }
+/** Claim one recurring scheduler across all deployments of an app. */
+export declare function acquireAutomationSchedulerLease(input?: {
+    appId?: string;
+    now?: number;
+    leaseMs?: number;
+}): Promise<string | null>;
+/** Renew a lease while a slow sweep is still executing. */
+export declare function renewAutomationSchedulerLease(input: {
+    appId?: string;
+    owner: string;
+    now?: number;
+    leaseMs?: number;
+}): Promise<boolean>;
+/** Release only the lease owned by this invocation. */
+export declare function releaseAutomationSchedulerLease(input: {
+    appId?: string;
+    owner: string;
+}): Promise<void>;
 /** Record the last scheduler tick without making health bookkeeping fatal. */
 export declare function recordAutomationSchedulerHealth(input: {
     appId?: string;

package/dist/jobs/scheduler-health.js

@@ -1,9 +1,12 @@
+import { randomUUID } from "node:crypto";
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { runMigrations } from "../db/migrations.js";
 const TABLE = "automation_scheduler_health";
 const DEFAULT_APP_ID = "default";
 const MAX_ERROR_LENGTH = 500;
+export const AUTOMATION_SCHEDULER_LEASE_MS = 10 * 60_000;
+export const AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS = 60_000;
 /** Authoritative release-time schema for recurring scheduler health. */
 export const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS = [
     {
@@ -30,6 +33,14 @@ export const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_${TABLE}_updated ON ${TABLE} (updated_at)
     `,
     },
+    {
+        version: 2,
+        name: "automation-scheduler-health-lease",
+        sql: `
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_owner TEXT;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_expires_at INTEGER;
+    `,
+    },
 ];
 export async function runAutomationSchedulerHealthMigrations(nitroApp) {
     await runMigrations(AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS, {
@@ -56,7 +67,9 @@ async function ensureHealthTable() {
           last_dispatched_at ${intType()},
           last_error TEXT,
           runtime TEXT,
-          updated_at ${intType()} NOT NULL
+          updated_at ${intType()} NOT NULL,
+          lease_owner TEXT,
+          lease_expires_at ${intType()}
         )
       `;
             const indexSql = `CREATE INDEX IF NOT EXISTS idx_${TABLE}_updated ON ${TABLE} (updated_at)`;
@@ -69,6 +82,8 @@ async function ensureHealthTable() {
                 await ensureColumnExists(TABLE, "last_error", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_error TEXT`);
                 await ensureColumnExists(TABLE, "runtime", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS runtime TEXT`);
                 await ensureColumnExists(TABLE, "updated_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS updated_at ${intType()}`);
+                await ensureColumnExists(TABLE, "lease_owner", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_owner TEXT`);
+                await ensureColumnExists(TABLE, "lease_expires_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_expires_at ${intType()}`);
                 await ensureIndexExists(`idx_${TABLE}_updated`, indexSql);
                 return;
             }
@@ -84,6 +99,8 @@ async function ensureHealthTable() {
                 ["last_error", "TEXT"],
                 ["runtime", "TEXT"],
                 ["updated_at", `${intType()} NOT NULL DEFAULT 0`],
+                ["lease_owner", "TEXT"],
+                ["lease_expires_at", `${intType()}`],
             ]) {
                 if (columns.has(name))
                     continue;
@@ -106,6 +123,74 @@ async function ensureHealthTable() {
     }
     return initPromise;
 }
+function isUniqueViolation(error) {
+    const candidate = error;
+    return (candidate?.code === "23505" ||
+        /unique|duplicate|already exists/i.test(String(candidate?.message ?? error)));
+}
+function leaseRowId(appId) {
+    return rowIdForScope(appId, null);
+}
+/** Claim one recurring scheduler across all deployments of an app. */
+export async function acquireAutomationSchedulerLease(input = {}) {
+    await ensureHealthTable();
+    const appId = normalizeAppId(input.appId);
+    const id = leaseRowId(appId);
+    const now = input.now ?? Date.now();
+    const leaseMs = Math.max(input.leaseMs ?? AUTOMATION_SCHEDULER_LEASE_MS, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS * 2);
+    const owner = randomUUID();
+    const expiresAt = now + leaseMs;
+    const client = getDbExec();
+    try {
+        await client.execute({
+            sql: `INSERT INTO ${TABLE}
+        (id, app_id, org_id, last_checked_at, last_dispatched_at, last_error, runtime, updated_at, lease_owner, lease_expires_at)
+        VALUES (?, ?, NULL, NULL, NULL, NULL, 'recurring-jobs', ?, ?, ?)`,
+            args: [id, appId, now, owner, expiresAt],
+        });
+        return owner;
+    }
+    catch (error) {
+        if (!isUniqueViolation(error))
+            throw error;
+    }
+    const result = await client.execute({
+        sql: `UPDATE ${TABLE}
+          SET lease_owner = ?, lease_expires_at = ?, updated_at = ?
+          WHERE id = ?
+            AND (lease_owner IS NULL OR lease_expires_at IS NULL OR lease_expires_at <= ?)`,
+        args: [owner, expiresAt, now, id, now],
+    });
+    return Number(result.rowsAffected ?? 0) > 0 ? owner : null;
+}
+/** Renew a lease while a slow sweep is still executing. */
+export async function renewAutomationSchedulerLease(input) {
+    await ensureHealthTable();
+    const now = input.now ?? Date.now();
+    const expiresAt = now + Math.max(input.leaseMs ?? AUTOMATION_SCHEDULER_LEASE_MS, 0);
+    const result = await getDbExec().execute({
+        sql: `UPDATE ${TABLE}
+          SET lease_expires_at = ?, updated_at = ?
+          WHERE id = ? AND lease_owner = ?`,
+        args: [
+            expiresAt,
+            now,
+            leaseRowId(normalizeAppId(input.appId)),
+            input.owner,
+        ],
+    });
+    return Number(result.rowsAffected ?? 0) > 0;
+}
+/** Release only the lease owned by this invocation. */
+export async function releaseAutomationSchedulerLease(input) {
+    await ensureHealthTable();
+    await getDbExec().execute({
+        sql: `UPDATE ${TABLE}
+          SET lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+          WHERE id = ? AND lease_owner = ?`,
+        args: [Date.now(), leaseRowId(normalizeAppId(input.appId)), input.owner],
+    });
+}
 function fromRow(row) {
     return {
         appId: String(row.app_id ?? DEFAULT_APP_ID),

package/dist/jobs/scheduler.js

@@ -3,7 +3,7 @@ import { backgroundRunCutOffReason, isBackgroundAutomationRunActive, resolveBack
 import { nextOccurrence, isValidCron, describeCron, effectiveTimezone, } from "./cron.js";
 import { buildJobResourceContent, parseJobResource, } from "./frontmatter.js";
 import { claimAutomationRun, finishAutomationRun, getAutomationRun, listAutomationRuns, } from "./run-history.js";
-import { recordAutomationSchedulerHealth } from "./scheduler-health.js";
+import { acquireAutomationSchedulerLease, recordAutomationSchedulerHealth, releaseAutomationSchedulerLease, renewAutomationSchedulerLease, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS, } from "./scheduler-health.js";
 // ─── Frontmatter parsing ────────────────────────────────────────────────────
 export { classifyJobFrontmatter, classifyJobResource, normalizeJobMcpTools, parseJobResource, } from "./frontmatter.js";
 export function parseJobFrontmatter(content) {
@@ -74,6 +74,43 @@ function subscribeToJobsResourceEvents() {
  * one job cannot run twice while leaving other due jobs waiting behind it.
  */
 export async function processRecurringJobs(deps) {
+    const leaseOwner = await acquireAutomationSchedulerLease({
+        appId: deps.appId,
+    });
+    if (!leaseOwner)
+        return;
+    const leaseRenewal = setInterval(() => {
+        void renewAutomationSchedulerLease({
+            appId: deps.appId,
+            owner: leaseOwner,
+        }).catch((error) => {
+            console.warn("[recurring-jobs] Scheduler lease renewal failed:", error instanceof Error ? error.message : error);
+        });
+    }, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS);
+    let primaryFailed = false;
+    try {
+        await processRecurringJobsWithLease(deps);
+    }
+    catch (error) {
+        primaryFailed = true;
+        throw error;
+    }
+    finally {
+        clearInterval(leaseRenewal);
+        try {
+            await releaseAutomationSchedulerLease({
+                appId: deps.appId,
+                owner: leaseOwner,
+            });
+        }
+        catch (releaseError) {
+            console.warn("[recurring-jobs] Scheduler lease release failed:", releaseError instanceof Error ? releaseError.message : releaseError);
+            if (!primaryFailed)
+                throw releaseError;
+        }
+    }
+}
+async function processRecurringJobsWithLease(deps) {
     subscribeToJobsResourceEvents();
     // Skip if we recently confirmed there are no job resources to run.
     const nowMs = Date.now();

package/dist/mcp-client/routes.d.ts

@@ -6,6 +6,9 @@
  * hot-reload the configured server set.
  *
  *   GET    /_agent-native/mcp/servers           list user + org servers
+ *   GET    /_agent-native/mcp/servers/runtime-config
+ *                                                reserved; returns 410 until a
+ *                                                desktop capability broker exists
  *   POST   /_agent-native/mcp/servers           add a server
  *   DELETE /_agent-native/mcp/servers/:id       remove a server (scope via ?scope=)
  *   POST   /_agent-native/mcp/servers/:id/test  dry-run connect (no persist)