@agent-native/core 0.153.2 → 0.153.5

package/corpus/templates/clips/desktop/src-tauri/src/native_screen.rs

@@ -4486,8 +4486,8 @@ pub(crate) fn persist_shared_clip_recording(
     server_url: &str,
     recording_id: &str,
     duration_ms: u128,
-    width: u32,
-    height: u32,
+    width: Option<u32>,
+    height: Option<u32>,
     include_mic: bool,
     include_system_audio: bool,
     has_camera: bool,
@@ -4506,8 +4506,8 @@ pub(crate) fn persist_shared_clip_recording(
         segment_paths: Vec::new(),
         mime_type: MP4_RECORDING_MIME_TYPE.to_string(),
         duration_ms,
-        width: Some(width),
-        height: Some(height),
+        width,
+        height,
         bytes,
         has_audio: include_mic || include_system_audio,
         mic_captured: include_mic,
@@ -4532,8 +4532,11 @@ pub(crate) fn clear_shared_clip_recording(app: &AppHandle, recording_id: &str, p
     let saved = read_saved_recording_metadata(app, recording_id).ok();
     if let Some(saved) = saved {
         clear_saved_recording_after_success(app, &saved);
-    } else if let Err(error) = remove_saved_file(path, "shared Clip temporary artifact") {
-        eprintln!("[clips-tray] shared Clip cleanup failed: {error}");
+    } else {
+        remove_recording_intent(path);
+        if let Err(error) = remove_saved_file(path, "shared Clip temporary artifact") {
+            eprintln!("[clips-tray] shared Clip cleanup failed: {error}");
+        }
     }
     let _ = app.emit("clips:pending-uploads-changed", ());
 }

package/corpus/templates/clips/desktop/src-tauri/src/rewind_clip.rs

@@ -1038,6 +1038,7 @@ fn materialize(
     label: &str,
     include_mic: bool,
     include_system_audio: bool,
+    recovery: Option<(&str, &str, bool)>,
 ) -> Result<FinalizedNativeArtifact, String> {
     let active = take_active(state)?;
     let mut intervals = active.intervals.clone();
@@ -1112,10 +1113,25 @@ fn materialize(
         }
         let output = artifact_path(app, label)?;
         let audio = select_audio(&active.sources, include_mic, include_system_audio)?;
-        native_screen::materialize_mp4_slices_exact(&slices, &output, audio)?;
         let first = first_segment
             .as_ref()
             .ok_or_else(|| "no Rewind media selected".to_string())?;
+        if let Some((server_url, recording_id, has_camera)) = recovery {
+            native_screen::persist_recording_intent(
+                &output,
+                recording_id,
+                server_url,
+                native_screen::MP4_RECORDING_MIME_TYPE,
+                first.width,
+                first.height,
+                include_mic || include_system_audio,
+                include_mic,
+                include_system_audio,
+                has_camera,
+                true,
+            )?;
+        }
+        native_screen::materialize_mp4_slices_exact(&slices, &output, audio)?;
         Ok(FinalizedNativeArtifact::rewind_mp4(
             output,
             duration_ms,
@@ -1199,8 +1215,8 @@ pub(crate) async fn rewind_clip_stop_and_upload(
                         &server_url,
                         &recording_id,
                         logical_duration_ms as u128,
-                        sink_width,
-                        sink_height,
+                        Some(sink_width),
+                        Some(sink_height),
                         include_mic,
                         include_system_audio,
                         has_camera,
@@ -1230,8 +1246,8 @@ pub(crate) async fn rewind_clip_stop_and_upload(
                 &server_url,
                 &recording_id,
                 result.duration_ms as u128,
-                result.width,
-                result.height,
+                Some(result.width),
+                Some(result.height),
                 include_mic,
                 include_system_audio,
                 has_camera,
@@ -1257,8 +1273,8 @@ pub(crate) async fn rewind_clip_stop_and_upload(
                         &server_url,
                         &recording_id,
                         result.duration_ms as u128,
-                        result.width,
-                        result.height,
+                        Some(result.width),
+                        Some(result.height),
                         include_mic,
                         include_system_audio,
                         has_camera,
@@ -1314,19 +1330,62 @@ pub(crate) async fn rewind_clip_stop_and_upload(
         &recording_id,
         include_mic,
         include_system_audio,
+        Some((&server_url, &recording_id, has_camera)),
+    )?;
+    native_screen::persist_shared_clip_recording(
+        &app,
+        &artifact.path,
+        &server_url,
+        &recording_id,
+        artifact.duration_ms,
+        artifact.width,
+        artifact.height,
+        include_mic,
+        include_system_audio,
+        has_camera,
+        None,
     )?;
-    native_screen::upload_finalized_native_artifact(
+    let recovery_server_url = server_url.clone();
+    let recovery_recording_id = recording_id.clone();
+    let artifact_path = artifact.path.clone();
+    let result = native_screen::upload_finalized_native_artifact(
         &app,
         &artifact,
         server_url,
-        recording_id,
+        recording_id.clone(),
         auth_token.unwrap_or_default(),
         cookie.unwrap_or_default(),
         NativeUploadMode::from_option(upload_mode),
         include_mic || include_system_audio,
         has_camera,
     )
-    .await
+    .await;
+    match &result {
+        Ok(upload) if !upload.verification_pending => {
+            native_screen::clear_shared_clip_recording(
+                &app,
+                &recovery_recording_id,
+                &artifact_path,
+            );
+        }
+        Err(error) => {
+            let _ = native_screen::persist_shared_clip_recording(
+                &app,
+                &artifact_path,
+                &recovery_server_url,
+                &recovery_recording_id,
+                artifact.duration_ms,
+                artifact.width,
+                artifact.height,
+                include_mic,
+                include_system_audio,
+                has_camera,
+                Some(error),
+            );
+        }
+        _ => {}
+    }
+    result
 }
 
 #[tauri::command]
@@ -1390,6 +1449,7 @@ pub(crate) async fn rewind_clip_stop_and_save(
         &folder_name,
         include_mic,
         include_system_audio,
+        None,
     )?;
     native_screen::save_finalized_native_artifact_to_local_export(
         &app,

package/corpus/templates/forms/AGENTS.md

@@ -32,6 +32,12 @@ Read the relevant skill before deeper work:
   combined dashboard/report requests.
 - For form setup/configuration previews, call `preview-form`. It returns a
   native inline summary/table and an "Open editor" expansion path.
+- For product usage, agent-native signup, conversion, app-wide event, or other
+  data-owned-by-sibling questions, use `describe-workspace-apps` when ownership
+  is unclear, then delegate a narrow natural-language question with `call-agent`
+  to the owning app. In workspaces with Analytics, it normally owns first-party
+  signup, conversion, and app-usage metrics. Do not invent SQL or query another
+  app's database.
 - For an anonymous feedback form or survey, create all fields in one
   `create-form` call with `status: "published"`, verify the persisted form, and
   copy the returned `publicUrl` verbatim. Never derive the link from `slug` or

package/corpus/templates/forms/server/plugins/agent-chat.ts

@@ -25,6 +25,7 @@ Core rules:
 - Use the framework sharing actions for form and response resources.
 - Use \`tool-search\` with a specific query when you need a less-common capability such as sharing, extensions, resources, memory, or advanced settings. Search results load matching tool schemas into the next step.
 - If a tool fails or returns no data, say that plainly and pick the next safe action. Never fabricate success from a tool error.
+- When a question is about product usage, agent-native signups, conversions, app-wide events, or data owned by another workspace app, use \`describe-workspace-apps\` if ownership is unclear, then delegate a narrow natural-language question with \`call-agent\` to the owning app. In workspaces with Analytics, it normally owns first-party signup, conversion, and app-usage metrics. Do not invent SQL or query another app's database.
 
 Form UX guidance: keep forms focused with clear labels, sensible validation, minimal required fields, and progressive disclosure for advanced settings.`;
 

package/corpus/templates/mail/AGENTS.md

@@ -26,9 +26,10 @@ Read the relevant skill before deeper work:
   is connected, synthetic `local-emails` data otherwise. Call actions the same
   way either way, and never claim fallback data or a fallback send touched the
   user's real inbox.
-- Never send mail unless the user explicitly asks. Draft or queue for review by
-  default; `send-email` is `needsApproval: true`. Use `queue-email-draft` for
-  teammate or Slack-originated send requests.
+- Interactive sends require explicit user approval. Draft or queue for review by
+  default; automation-triggered sends remain approval-gated unless the owner
+  opts into Mail's "Allow automations to send emails automatically" setting.
+  Use `queue-email-draft` for teammate or Slack-originated send requests.
 - Resolve people with `find-contact` before drafting or sending. Never guess an
   address pattern; if it returns zero matches, tell the user.
 - Read `get-mail-settings` before drafting. Use the configured `signature`
@@ -66,7 +67,7 @@ Read the relevant skill before deeper work:
 | `get-hubspot-contact` | HubSpot contact + deals + tickets by email. |
 | `create-attachment-upload` | Short-lived upload URL for an attachment. |
 | `manage-draft` | Create/update/delete a `compose-{id}` draft. |
-| `send-email` | Real send; `needsApproval: true`. |
+| `send-email` | Real send; interactive calls require approval, while automation calls require the Mail opt-in setting. |
 | `queue-email-draft` / `list-queued-drafts` / `update-queued-draft` / `open-queued-draft` / `send-queued-drafts` | Teammate/Slack draft review. |
 | `mark-read` / `mark-thread-read` / `star-email` / `archive-email` / `unarchive-email` / `trash-email` / `untrash-email` / `move-email` | Message/thread state; `mark-read` does bulk cleanup. |
 | `send-scheduled-email-now` / `cancel-scheduled-email` | Send or cancel a scheduled send. |

package/corpus/templates/mail/actions/get-automation-settings.ts

@@ -4,10 +4,14 @@ import { getUserSetting } from "@agent-native/core/settings";
 import { z } from "zod";
 
 import { resolveAutomationModelSettings } from "../server/lib/automation-model.js";
+import {
+  allowsAutomationSends,
+  type MailAutomationSettings,
+} from "../server/lib/automation-settings.js";
 
 export default defineAction({
   description:
-    "Read the engine and model used to evaluate inbox automation rules, falling back to the app's configured agent engine.",
+    "Read the engine, model, and email-send permission used by inbox automations, falling back to the app's configured agent engine.",
   schema: z.object({}),
   http: { method: "GET" },
   agentTool: false,
@@ -15,10 +19,17 @@ export default defineAction({
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("Unauthenticated");
 
-    const data = (await getUserSetting(ownerEmail, "automation-settings")) as {
-      engine?: string;
-      model?: string;
-    } | null;
-    return resolveAutomationModelSettings(ownerEmail, data);
+    const data = (await getUserSetting(
+      ownerEmail,
+      "automation-settings",
+    )) as MailAutomationSettings | null;
+    const modelSettings = await resolveAutomationModelSettings(
+      ownerEmail,
+      data,
+    );
+    return {
+      ...modelSettings,
+      allowAutomationSends: allowsAutomationSends(data),
+    };
   },
 });

package/corpus/templates/mail/actions/send-email.ts

@@ -1,4 +1,5 @@
 import { defineAction } from "@agent-native/core";
+import type { ActionRunContext } from "@agent-native/core/action";
 import { writeAppState } from "@agent-native/core/application-state";
 import { emit } from "@agent-native/core/event-bus";
 import { setOAuthDisplayName } from "@agent-native/core/oauth-tokens";
@@ -8,6 +9,7 @@ import { getUserSetting } from "@agent-native/core/settings";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
+import { requiresEmailSendApproval } from "../server/lib/automation-settings.js";
 import {
   collectLinks,
   newClickToken,
@@ -109,7 +111,7 @@ const attachmentSchema = z.object({
 
 export default defineAction({
   description:
-    "Send an email via Gmail. IMPORTANT: Never call this unless the user explicitly asks to send — always draft first and show the content to the user for review before sending.",
+    "Send an email via Gmail. Interactive sends require approval. Automation-triggered sends require the owner to opt in through Mail settings; otherwise they remain approval-gated.",
   schema: z.object({
     to: z.string().describe("Recipient email(s), comma-separated"),
     subject: z.string().describe("Email subject"),
@@ -135,16 +137,22 @@ export default defineAction({
         "Files to attach. Each entry must reference a previously-uploaded file by its server-side `filename`. The upload must have been created via the media-upload endpoint before calling this action.",
       ),
   }),
-  // Human-in-the-loop gate: actually sending an email is outward-facing and
-  // hard to undo, so the agent can never send without a human approving the
-  // specific call. The loop pauses with `approval_required`; the user approves
-  // before the message goes out. Drafting/queueing is unaffected — only the
-  // real send is gated. This is the canonical (and intentionally rare) use of
-  // `needsApproval` in the framework.
-  needsApproval: true,
-  run: async (args) => {
+  // Interactive sends stay human-approved. Event-triggered automations may
+  // opt out through the owner's Mail Automation settings, which are read from
+  // trusted action context rather than from tool input.
+  needsApproval: (_args, ctx?: ActionRunContext) =>
+    requiresEmailSendApproval(ctx),
+  run: async (args, ctx) => {
     const ownerEmail = getRequestUserEmail();
     if (!ownerEmail) throw new Error("no authenticated user");
+    if (
+      ctx?.caller === "automation" &&
+      (await requiresEmailSendApproval(ctx))
+    ) {
+      throw new Error(
+        "Automation email sending is disabled. Enable it in Mail settings to send automatically.",
+      );
+    }
     const settings = await readSettings();
 
     // Resolve attachments eagerly — fail before touching Gmail if any are missing.

package/corpus/templates/mail/actions/send-queued-drafts.ts

@@ -1,6 +1,8 @@
 import { defineAction } from "@agent-native/core";
+import type { ActionRunContext } from "@agent-native/core/action";
 import { z } from "zod";
 
+import { requiresEmailSendApproval } from "../server/lib/automation-settings.js";
 import {
   claimQueuedDraftForSending,
   listQueuedDrafts,
@@ -32,7 +34,10 @@ type SendOutcome =
   | { outcome: "skipped"; id: string; reason: string }
   | { outcome: "failed"; id: string; error: string };
 
-async function sendOne(id: string): Promise<SendOutcome> {
+async function sendOne(
+  id: string,
+  actionContext?: ActionRunContext,
+): Promise<SendOutcome> {
   const claim = await claimQueuedDraftForSending(id);
   if (!claim.claimed) {
     if (claim.reason === "sent") {
@@ -50,14 +55,17 @@ async function sendOne(id: string): Promise<SendOutcome> {
 
   const { ctx, draft, claimId, priorStatus } = claim;
   try {
-    const result = await (sendEmailAction as any).run({
-      to: draft.to,
-      cc: draft.cc || undefined,
-      bcc: draft.bcc || undefined,
-      subject: draft.subject,
-      body: draft.body,
-      account: draft.accountEmail || undefined,
-    });
+    const result = await sendEmailAction.run(
+      {
+        to: draft.to,
+        cc: draft.cc || undefined,
+        bcc: draft.bcc || undefined,
+        subject: draft.subject,
+        body: draft.body,
+        account: draft.accountEmail || undefined,
+      },
+      actionContext,
+    );
 
     if (typeof result === "string" && result.startsWith("Error")) {
       throw new Error(result);
@@ -95,7 +103,9 @@ export default defineAction({
       .optional()
       .describe("Maximum drafts to send when all=true"),
   }),
-  run: async (args) => {
+  needsApproval: (_args, ctx?: ActionRunContext) =>
+    requiresEmailSendApproval(ctx),
+  run: async (args, ctx) => {
     let ids: string[] = [];
 
     if (args.all) {
@@ -127,7 +137,7 @@ export default defineAction({
     const failed: Array<{ id: string; error: string }> = [];
 
     for (const id of ids) {
-      const result = await sendOne(id);
+      const result = await sendOne(id, ctx);
       if (result.outcome === "sent") {
         sent.push(result);
       } else if (result.outcome === "failed") {

package/corpus/templates/mail/actions/update-automation-settings.ts

@@ -3,12 +3,18 @@ import { getRequestUserEmail } from "@agent-native/core/server";
 import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
 import { z } from "zod";
 
+import type { MailAutomationSettings } from "../server/lib/automation-settings.js";
+
 export default defineAction({
   description:
-    "Set the engine and model used to evaluate inbox automation rules.",
+    "Set the engine and model used to evaluate inbox automation rules, and choose whether automations may send email without per-message approval.",
   schema: z.object({
     engine: z.string().optional().describe("Agent engine id"),
     model: z.string().optional().describe("Model id for that engine"),
+    allowAutomationSends: z
+      .boolean()
+      .optional()
+      .describe("Allow automation-triggered emails to send without approval"),
   }),
   http: { method: "PUT" },
   agentTool: false,
@@ -17,17 +23,25 @@ export default defineAction({
     if (!ownerEmail) throw new Error("Unauthenticated");
 
     const existing =
-      ((await getUserSetting(ownerEmail, "automation-settings")) as {
-        engine?: string;
-        model?: string;
-      } | null) || {};
+      ((await getUserSetting(
+        ownerEmail,
+        "automation-settings",
+      )) as MailAutomationSettings | null) || {};
     const updated = {
       ...existing,
       ...(args.engine ? { engine: args.engine } : {}),
       ...(args.model ? { model: args.model } : {}),
+      ...(args.allowAutomationSends !== undefined
+        ? { allowAutomationSends: args.allowAutomationSends }
+        : {}),
     };
     await putUserSetting(ownerEmail, "automation-settings", updated);
 
-    return { success: true, engine: updated.engine, model: updated.model };
+    return {
+      success: true,
+      engine: updated.engine,
+      model: updated.model,
+      allowAutomationSends: updated.allowAutomationSends === true,
+    };
   },
 });

package/corpus/templates/mail/app/i18n/en-US.ts

@@ -478,6 +478,11 @@ const messages = {
     lastRun: "Last run:",
     automationsDescription:
       "Rules that automatically process new inbox emails using AI.",
+    allowAutomationSends: "Allow automations to send emails automatically",
+    allowAutomationSendsDescription:
+      "Off by default. Turn this on when you want automations to send emails without asking for approval each time.",
+    automationSendSettingSaveFailed:
+      "Could not save the automation email setting.",
     loadingModels: "Loading models",
     newRule: "New rule",
     noAutomationRules: "No automation rules yet.",

package/corpus/templates/mail/app/pages/SettingsPage.tsx

@@ -868,6 +868,12 @@ function TriggersSubsection() {
 
 // ─── Automations Section ─────────────────────────────────────────────────────
 
+type AutomationSettings = {
+  engine?: string;
+  model?: string;
+  allowAutomationSends: boolean;
+};
+
 function AutomationsSection() {
   const t = useT();
   const { data: rules = [], isLoading } = useAutomations();
@@ -896,9 +902,9 @@ function AutomationsSection() {
   // Refetch on any settings write or agent action so agent-driven changes
   // (e.g. update-automation-settings) show up without a manual refresh.
   const settingsSync = useChangeVersions(["settings", "action"]);
-  const { data: autoSettings } = useQuery({
+  const { data: autoSettings } = useQuery<AutomationSettings>({
     queryKey: ["automation-settings", settingsSync],
-    queryFn: async () => {
+    queryFn: async (): Promise<AutomationSettings> => {
       try {
         return await callAction(
           "get-automation-settings",
@@ -906,7 +912,7 @@ function AutomationsSection() {
           { method: "GET" },
         );
       } catch {
-        return { model: defaultModel };
+        return { model: defaultModel, allowAutomationSends: false };
       }
     },
     staleTime: 30_000,
@@ -914,6 +920,7 @@ function AutomationsSection() {
   });
 
   const queryClient = useQueryClient();
+  const [isSavingAutomationSends, setIsSavingAutomationSends] = useState(false);
   const selectedModel = autoSettings?.model || defaultModel;
   const selectedEngine =
     autoSettings?.engine ||
@@ -930,7 +937,13 @@ function AutomationsSection() {
   const handleModelChange = async (value: string) => {
     const [engine, model] = value.split("::");
     if (!engine || !model) return;
-    queryClient.setQueryData(["automation-settings"], { engine, model });
+    queryClient.setQueriesData<AutomationSettings>(
+      { queryKey: ["automation-settings"] },
+      (current) =>
+        current
+          ? { ...current, engine, model }
+          : { engine, model, allowAutomationSends: false },
+    );
     await callAction(
       "update-automation-settings",
       { engine, model },
@@ -938,6 +951,40 @@ function AutomationsSection() {
     );
   };
 
+  const handleAutomationSendsChange = async (enabled: boolean) => {
+    if (!autoSettings || isSavingAutomationSends) return;
+    const previous = autoSettings.allowAutomationSends;
+    queryClient.setQueriesData<AutomationSettings>(
+      { queryKey: ["automation-settings"] },
+      (current) =>
+        current ? { ...current, allowAutomationSends: enabled } : current,
+    );
+    setIsSavingAutomationSends(true);
+    try {
+      await callAction(
+        "update-automation-settings",
+        { allowAutomationSends: enabled },
+        { method: "PUT" },
+      );
+    } catch (error) {
+      queryClient.setQueriesData<AutomationSettings>(
+        { queryKey: ["automation-settings"] },
+        (current) =>
+          current ? { ...current, allowAutomationSends: previous } : current,
+      );
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("settings.automationSendSettingSaveFailed"),
+      );
+    } finally {
+      setIsSavingAutomationSends(false);
+      await queryClient.invalidateQueries({
+        queryKey: ["automation-settings"],
+      });
+    }
+  };
+
   const handleCreate = (data: {
     name: string;
     condition: string;
@@ -996,6 +1043,20 @@ function AutomationsSection() {
         </Button>
       </div>
 
+      <div className="max-w-2xl mb-6">
+        {autoSettings ? (
+          <SettingsSwitchRow
+            title={t("settings.allowAutomationSends")}
+            description={t("settings.allowAutomationSendsDescription")}
+            checked={autoSettings.allowAutomationSends}
+            disabled={isSavingAutomationSends}
+            onCheckedChange={handleAutomationSendsChange}
+          />
+        ) : (
+          <Skeleton className="h-16 w-full" />
+        )}
+      </div>
+
       {/* Content */}
       <div className="max-w-2xl space-y-2">
         {/* New rule form */}
@@ -1219,7 +1280,7 @@ function DraftingSection() {
   );
 }
 
-function TrackingRow({
+function SettingsSwitchRow({
   title,
   description,
   checked,
@@ -1281,13 +1342,13 @@ function TrackingSection() {
           </>
         ) : (
           <>
-            <TrackingRow
+            <SettingsSwitchRow
               title={t("settings.trackEmailOpens")}
               description={t("settings.trackEmailOpensDescription")}
               checked={tracking.opens}
               onCheckedChange={(v) => update({ opens: v })}
             />
-            <TrackingRow
+            <SettingsSwitchRow
               title={t("settings.trackLinkClicks")}
               description={t("settings.trackLinkClicksDescription")}
               checked={tracking.clicks}

package/corpus/templates/mail/server/lib/automation-settings.ts

@@ -0,0 +1,27 @@
+import type { ActionRunContext } from "@agent-native/core/action";
+import { getUserSetting } from "@agent-native/core/settings";
+
+export type MailAutomationSettings = {
+  engine?: string;
+  model?: string;
+  allowAutomationSends?: boolean;
+};
+
+export function allowsAutomationSends(settings: unknown): boolean {
+  return (
+    typeof settings === "object" &&
+    settings !== null &&
+    "allowAutomationSends" in settings &&
+    (settings as { allowAutomationSends?: unknown }).allowAutomationSends ===
+      true
+  );
+}
+
+export async function requiresEmailSendApproval(
+  ctx?: ActionRunContext,
+): Promise<boolean> {
+  if (ctx?.caller !== "automation" || !ctx.userEmail) return true;
+
+  const settings = await getUserSetting(ctx.userEmail, "automation-settings");
+  return !allowsAutomationSends(settings);
+}

package/corpus/templates/mail/server/plugins/agent-chat.ts

@@ -151,6 +151,8 @@ Be concise and helpful. When summarizing emails, include sender, subject, and a
 You can create and manage email automation rules that process new inbox emails automatically using AI.
 Use manage-automations to create rules like "auto-label newsletters", "star emails from my boss", etc.
 
+Sending email from an automation is opt-in. Mail keeps "Allow automations to send emails automatically" off by default. When it is off, an automation may draft or queue an email, but a real send remains approval-gated. Turning it on lets event-triggered automations send without asking for approval each time; it does not remove approval from normal interactive sends.
+
 Examples:
 - User says "auto-label newsletters" \u2192 create rule with condition "from a newsletter or marketing mailing list" and action label:"newsletters"
 - User says "archive marketing emails" \u2192 create rule with condition "marketing or promotional email" and action archive

package/corpus/templates/slides/app/components/editor/EditorSidebar.tsx

@@ -441,9 +441,9 @@ export default function EditorSidebar({
         const nextSlideId = slides[nextIndex].id;
         onSelectSlide(nextSlideId);
         requestAnimationFrame(() => {
-          slideButtonRefs.current.get(nextSlideId)?.focus({
-            preventScroll: true,
-          });
+          const nextButton = slideButtonRefs.current.get(nextSlideId);
+          nextButton?.focus({ preventScroll: true });
+          nextButton?.scrollIntoView({ block: "nearest" });
         });
       }
     };