@agent-native/core 0.134.0 → 0.135.0

package/corpus/core/src/server/email-templates.ts

@@ -11,13 +11,22 @@
  * site — keeps the transactional look-and-feel consistent.
  */
 
-import { getAppName } from "./app-name.js";
+import { getAppName, getAppSlug, getAppDescription } from "./app-name.js";
 import { renderEmail, emailStrong } from "./email-template.js";
 
+/** Shared reply-to for the framework's transactional emails. */
+export const AGENT_NATIVE_REPLY_TO = "agent-native@builder.io";
+
 export interface RenderedEmailMessage {
   subject: string;
   html: string;
   text: string;
+  /**
+   * Per-app sender branding, applied by `sendEmail` only on first-party
+   * agent-native.com deployments. Self-hosted deployments keep the sender and
+   * reply-to they configured via EMAIL_FROM.
+   */
+  appSender?: { name: string; slug: string; replyTo?: string };
 }
 
 /**
@@ -33,6 +42,17 @@ function resolveAppName(): string {
   return stripCrlf(getAppName() || "Agent Native");
 }
 
+/**
+ * Recipient-facing brand for auth emails. Only a recognized first-party
+ * template is presented as "Agent-Native <App>"; a custom deployment keeps its
+ * own name so its users aren't told they signed up for an Agent Native app.
+ */
+function resolveBrand(slug: string | undefined): string {
+  const appName = getAppName();
+  if (!appName) return "Agent Native";
+  return slug ? `Agent-Native ${stripCrlf(appName)}` : stripCrlf(appName);
+}
+
 // ---------------------------------------------------------------------------
 // Organization invitation
 // ---------------------------------------------------------------------------
@@ -89,28 +109,58 @@ export interface RenderVerifySignupEmailArgs {
   verifyUrl: string;
 }
 
+/**
+ * Customer-facing description overrides for the verification email body. The
+ * default descriptions come from the app-picker hints, which name competitors
+ * for internal positioning; these rewrites frame them as "replacement" for a
+ * customer-facing email without changing the picker copy.
+ */
+const VERIFY_EMAIL_DESCRIPTIONS: Record<string, string> = {
+  calendar:
+    "Agent-native Google Calendar replacement — manage events, sync, and public booking",
+  content:
+    "Open-source Obsidian/Notion replacement for MDX — edit local docs with agent assistance",
+  slides:
+    "Agent-native Google Slides replacement — generate and edit React presentations",
+  analytics:
+    "Agent-native Amplitude/Mixpanel replacement — connect data sources, prompt for charts",
+  mail: "Agent-native Superhuman replacement — email client with keyboard shortcuts and AI triage",
+};
+
 export function renderVerifySignupEmail(
   args: RenderVerifySignupEmailArgs,
 ): RenderedEmailMessage {
   const email = stripCrlf(args.email);
-  const appName = resolveAppName();
+  const slug = getAppSlug();
+  const brand = resolveBrand(slug);
+  const description = slug
+    ? (VERIFY_EMAIL_DESCRIPTIONS[slug] ?? getAppDescription())
+    : undefined;
+
+  const paragraphs = [
+    `Thanks for signing up for ${emailStrong(brand)}. To finish creating your account, confirm that ${emailStrong(email)} is your email address.`,
+  ];
+  if (description) {
+    paragraphs.push(`${stripCrlf(description).replace(/\.\s*$/, "")}.`);
+  }
+  paragraphs.push(`This link expires in 1 hour.`);
 
   const { html, text } = renderEmail({
-    brandName: appName,
-    preheader: `Confirm ${email} to finish setting up your ${appName} account.`,
-    heading: `Verify your email for ${appName}`,
-    paragraphs: [
-      `Thanks for signing up for ${emailStrong(appName)}. To finish creating your account, confirm that ${emailStrong(email)} is your email address.`,
-      `This link expires in 1 hour.`,
-    ],
+    brandName: brand,
+    preheader: `Confirm ${email} to finish setting up your ${brand} account.`,
+    heading: `Verify your email for ${brand}`,
+    paragraphs,
     cta: { label: "Verify email", url: args.verifyUrl },
     footer: `If you didn't sign up, you can safely ignore this email.`,
   });
 
   return {
-    subject: `Verify your email for ${appName}`,
+    subject: `Verify your email for ${brand}`,
     html,
     text,
+    appSender: slug
+      ? { name: brand, slug, replyTo: AGENT_NATIVE_REPLY_TO }
+      : undefined,
   };
 }
 
@@ -129,12 +179,15 @@ export function renderResetPasswordEmail(
   args: RenderResetPasswordEmailArgs,
 ): RenderedEmailMessage {
   const email = stripCrlf(args.email);
-  const appName = resolveAppName();
+  // Match the verification email branding so password resets are clearly tied
+  // to the specific app. No value pitch here — it's a security email.
+  const slug = getAppSlug();
+  const brand = resolveBrand(slug);
 
   const { html, text } = renderEmail({
-    brandName: appName,
+    brandName: brand,
     preheader: `Reset the password for ${email}. This link expires in 1 hour.`,
-    heading: `Reset your ${appName} password`,
+    heading: `Reset your ${brand} password`,
     paragraphs: [
       `Someone requested a password reset for ${emailStrong(email)}. Click the button below to choose a new password.`,
       `This link expires in 1 hour.`,
@@ -144,8 +197,11 @@ export function renderResetPasswordEmail(
   });
 
   return {
-    subject: `Reset your ${appName} password`,
+    subject: `Reset your ${brand} password`,
     html,
     text,
+    appSender: slug
+      ? { name: brand, slug, replyTo: AGENT_NATIVE_REPLY_TO }
+      : undefined,
   };
 }

package/corpus/core/src/server/email.ts

@@ -39,6 +39,14 @@ export interface SendEmailArgs {
   fromName?: string;
   cc?: string | string[];
   replyTo?: string;
+  /**
+   * Per-app branding for first-party agent-native.com deployments. Applied
+   * only when the configured EMAIL_FROM is already on agent-native.com, so a
+   * self-hosted deployment keeps its own verified sender and support mailbox
+   * instead of sending as an unverified address a provider would reject.
+   * An explicit `from` / `replyTo` always wins.
+   */
+  appSender?: { name: string; slug: string; replyTo?: string };
   inReplyTo?: string;
   references?: string;
   attachments?: EmailAttachment[];
@@ -150,6 +158,56 @@ function withDisplayName(from: string, name: string): string {
   return `"${safe}" <${address}>`;
 }
 
+const AGENT_NATIVE_SENDER_DOMAIN = "agent-native.com";
+
+/**
+ * Resolve the per-app sender address, but only for deployments whose
+ * configured sender is already on agent-native.com. Any other (or missing)
+ * EMAIL_FROM means we cannot prove the branded address is a verified sender,
+ * so the deployment's own configuration is left untouched.
+ */
+let warnedAppSenderSuppressed = false;
+
+/**
+ * Suppressing the branding is correct for a sender we cannot prove we own,
+ * but it must not be invisible, or an operator sees generic senders with
+ * nothing pointing at why.
+ *
+ * EMAIL_FROM resolves per user/org/workspace through the scoped secret store,
+ * so the resolved address is tenant data and must never reach shared logs, and
+ * anything keyed by it would grow without bound in a warm worker. The message
+ * therefore carries no tenant values, which also makes it identical for every
+ * suppressed config — so emitting it once per process loses nothing.
+ */
+function warnAppSenderSuppressed(): void {
+  if (warnedAppSenderSuppressed) return;
+  warnedAppSenderSuppressed = true;
+  console.warn(
+    `[agent-native:email] Per-app sender branding is off because the ` +
+      `configured EMAIL_FROM is not on ${AGENT_NATIVE_SENDER_DOMAIN}. ` +
+      `Transactional email keeps the configured sender. Expected when self-hosting.`,
+  );
+}
+
+function resolveAppSender(
+  configuredFrom: string | undefined,
+  appSender: SendEmailArgs["appSender"],
+): { address: string; name: string; replyTo?: string } | undefined {
+  if (!appSender) return undefined;
+  const address = configuredFrom
+    ? parseSendGridFrom(configuredFrom).email.toLowerCase()
+    : undefined;
+  if (!address?.endsWith(`@${AGENT_NATIVE_SENDER_DOMAIN}`)) {
+    warnAppSenderSuppressed();
+    return undefined;
+  }
+  return {
+    address: `${appSender.slug}@${AGENT_NATIVE_SENDER_DOMAIN}`,
+    name: appSender.name,
+    replyTo: appSender.replyTo,
+  };
+}
+
 async function sendEmailWithSignal(
   args: SendEmailArgs,
   signal?: AbortSignal,
@@ -157,7 +215,12 @@ async function sendEmailWithSignal(
   const config = await resolveEmailTransport();
   signal?.throwIfAborted();
   const provider = config.provider;
-  const from = getFromAddress(config, args.from, args.fromName);
+  const branded = resolveAppSender(config.from, args.appSender);
+  const from =
+    branded && !args.from
+      ? withDisplayName(branded.address, args.fromName ?? branded.name)
+      : getFromAddress(config, args.from, args.fromName);
+  const replyTo = args.replyTo ?? branded?.replyTo;
   const attachments = resolveAttachments(args);
 
   if (provider === "resend") {
@@ -169,7 +232,7 @@ async function sendEmailWithSignal(
       text: args.text,
     };
     if (args.cc) payload.cc = Array.isArray(args.cc) ? args.cc : [args.cc];
-    if (args.replyTo) payload.reply_to = args.replyTo;
+    if (replyTo) payload.reply_to = replyTo;
     if (attachments?.length) {
       payload.attachments = attachments.map((a) => ({
         filename: a.filename,
@@ -220,7 +283,7 @@ async function sendEmailWithSignal(
         { type: "text/html", value: args.html },
       ],
     };
-    if (args.replyTo) sgPayload.reply_to = parseSendGridFrom(args.replyTo);
+    if (replyTo) sgPayload.reply_to = parseSendGridFrom(replyTo);
     const sgHeaders: Record<string, string> = {};
     if (args.inReplyTo) sgHeaders["In-Reply-To"] = args.inReplyTo;
     if (args.references) sgHeaders["References"] = args.references;

package/corpus/core/src/server/index.ts

@@ -547,6 +547,16 @@ export {
   type EmailProvider,
   type SendEmailArgs,
 } from "./email.js";
+export {
+  notifyActivity,
+  runActivityNotification,
+  resolveActivityRecipients,
+  type ActivityDeliveryFailure,
+  type ActivityNotificationResult,
+  type ActivityNotificationStatus,
+  type NotifyActivityInput,
+  type ResolveActivityRecipientsInput,
+} from "./activity-notifications.js";
 export {
   renderEmail,
   emailStrong,

package/corpus/core/src/sharing/index.ts

@@ -34,3 +34,8 @@ export {
   type AccessContext,
   type ResolvedAccess,
 } from "./access.js";
+
+export {
+  filterRecipientsByResourceAccess,
+  type FilterRecipientsInput,
+} from "./recipients.js";

package/corpus/core/src/sharing/recipients.ts

@@ -0,0 +1,67 @@
+import { isOrgMember } from "../org/membership.js";
+import { resolveAccess } from "./access.js";
+import { roleSatisfies, type ShareRole } from "./schema.js";
+
+export interface FilterRecipientsInput {
+  resourceType: string;
+  resourceId: string;
+  emails: Iterable<string>;
+  /** The resource's org, needed to honor `org` visibility. */
+  orgId?: string | null;
+  minimumRole?: ShareRole;
+  /**
+   * Override for resources that are not registered through `registerShareableResource`
+   * (the review registry resolves its own). Must honor `userEmail`/`orgId`
+   * rather than the ambient request, or the filter checks the wrong principal.
+   */
+  resolveRole?: (ctx: {
+    userEmail: string;
+    orgId?: string;
+  }) => Promise<{ role: string } | null>;
+}
+
+/**
+ * Keep only the addresses that can still open the resource *right now*.
+ *
+ * Notification recipient lists are built from historical rows — thread
+ * authors, stored mentions, caller-supplied addresses — none of which are an
+ * access grant. Without this, mentioning an arbitrary address mails it the
+ * comment body, and a collaborator whose share was revoked keeps receiving the
+ * thread. Access is re-resolved per address against the live ACL.
+ */
+export async function filterRecipientsByResourceAccess({
+  resourceType,
+  resourceId,
+  emails,
+  orgId,
+  minimumRole = "viewer",
+  resolveRole,
+}: FilterRecipientsInput): Promise<string[]> {
+  const resolve =
+    resolveRole ??
+    ((ctx: { userEmail: string; orgId?: string }) =>
+      resolveAccess(resourceType, resourceId, ctx));
+  const unique = new Set<string>();
+  for (const raw of emails) {
+    const email = raw.trim().toLowerCase();
+    if (email) unique.add(email);
+  }
+  if (unique.size === 0) return [];
+
+  const decisions = await Promise.all(
+    [...unique].map(async (email) => {
+      // Resolve without an org first: passing the resource's org up front
+      // would hand org-visibility access to anyone who is not in it.
+      const direct = await resolve({ userEmail: email });
+      if (direct && roleSatisfies(direct.role as ShareRole, minimumRole)) {
+        return email;
+      }
+      if (!orgId || !(await isOrgMember(orgId, email))) return null;
+      const viaOrg = await resolve({ userEmail: email, orgId });
+      return viaOrg && roleSatisfies(viaOrg.role as ShareRole, minimumRole)
+        ? email
+        : null;
+    }),
+  );
+  return decisions.filter((email): email is string => email !== null);
+}

package/corpus/core/src/triggers/actions/list-automations.ts

@@ -5,7 +5,12 @@ import {
   listAutomationDefinitions,
   type AutomationScope,
 } from "../../automations/service.js";
-import { describeCron, isValidCron, nextOccurrence } from "../../jobs/cron.js";
+import {
+  describeCron,
+  effectiveTimezone,
+  isValidCron,
+  nextOccurrence,
+} from "../../jobs/cron.js";
 
 const scopeSchema = z.enum(["personal", "organization"]);
 
@@ -13,15 +18,23 @@ function nextRun(
   meta: Awaited<ReturnType<typeof listAutomationDefinitions>>[number]["meta"],
 ): string | null {
   if (!meta.enabled) return null;
-  if (meta.nextRun) return meta.nextRun;
-  if (
+  const scheduled = Boolean(
     meta.triggerType === "schedule" &&
     meta.schedule &&
-    isValidCron(meta.schedule)
-  ) {
-    return nextOccurrence(meta.schedule).toISOString();
+    isValidCron(meta.schedule),
+  );
+  // A stored `nextRun` in the past means the dispatcher kept declining to run
+  // this automation, not that it is overdue. Report the real next occurrence
+  // and let `lastError` carry the reason it keeps being passed over.
+  if (meta.nextRun) {
+    const stored = new Date(meta.nextRun).getTime();
+    if (!Number.isFinite(stored) || stored > Date.now() || !scheduled) {
+      return meta.nextRun;
+    }
   }
-  return null;
+  return scheduled
+    ? nextOccurrence(meta.schedule!, undefined, meta.timezone).toISOString()
+    : null;
 }
 
 export interface AutomationActionItem {
@@ -32,11 +45,13 @@ export interface AutomationActionItem {
   triggerType: "event" | "schedule";
   event: string | null;
   schedule: string | null;
+  timezone: string | null;
   scheduleDescription: string | null;
   condition: string | null;
   body: string;
   enabled: boolean;
   lastRun: string | null;
+  lastCheck: string | null;
   lastStatus: string | null;
   lastError: string | null;
   nextRun: string | null;
@@ -76,11 +91,15 @@ export default defineAction({
       triggerType: meta.triggerType,
       event: meta.event ?? null,
       schedule: meta.schedule || null,
-      scheduleDescription: meta.schedule ? describeCron(meta.schedule) : null,
+      timezone: meta.schedule ? effectiveTimezone(meta.timezone) : null,
+      scheduleDescription: meta.schedule
+        ? describeCron(meta.schedule, effectiveTimezone(meta.timezone))
+        : null,
       condition: meta.condition ?? null,
       body,
       enabled: meta.enabled,
       lastRun: meta.lastRun ?? null,
+      lastCheck: meta.lastCheck ?? null,
       lastStatus: meta.lastStatus ?? null,
       lastError: meta.lastError ?? null,
       nextRun: nextRun(meta),

package/corpus/core/src/triggers/actions/manage-automation.ts

@@ -16,8 +16,10 @@ export default defineAction({
     name: z.string().min(1),
     scope: z.enum(["personal", "organization"]).default("personal"),
     enabled: z.boolean().optional(),
+    schedule: z.string().min(1).optional(),
+    timezone: z.string().min(1).optional(),
   }),
-  run: async ({ operation, name, scope, enabled }, ctx) => {
+  run: async ({ operation, name, scope, enabled, schedule, timezone }, ctx) => {
     const userEmail = ctx?.userEmail;
     if (!userEmail) throw new Error("Not authenticated.");
     const actor = { userEmail, orgId: ctx?.orgId };
@@ -27,20 +29,29 @@ export default defineAction({
       await refreshEventSubscriptions();
       return { deleted: true, name };
     }
-    if (enabled === undefined) {
-      throw Object.assign(new Error("enabled is required for update."), {
-        statusCode: 400,
-      });
+    if (
+      enabled === undefined &&
+      schedule === undefined &&
+      timezone === undefined
+    ) {
+      throw Object.assign(
+        new Error("enabled, schedule, or timezone is required for update."),
+        { statusCode: 400 },
+      );
     }
     const definition = await updateAutomation(actor, {
       name,
       scope,
-      enabled,
+      ...(enabled === undefined ? {} : { enabled }),
+      ...(schedule === undefined ? {} : { schedule }),
+      ...(timezone === undefined ? {} : { timezone }),
     });
     await refreshEventSubscriptions();
     return {
       name,
       enabled: definition.meta.enabled,
+      schedule: definition.meta.schedule || null,
+      timezone: definition.meta.timezone ?? null,
       nextRun: definition.meta.nextRun ?? null,
     };
   },

package/corpus/core/src/triggers/actions.ts

@@ -18,7 +18,7 @@ import {
   type AutomationScope,
 } from "../automations/service.js";
 import { listEvents } from "../event-bus/index.js";
-import { describeCron } from "../jobs/cron.js";
+import { describeCron, effectiveTimezone } from "../jobs/cron.js";
 import {
   getIntegrationRequestContext,
   getRequestOrgId,
@@ -71,7 +71,10 @@ async function handleList(
       triggerType: meta.triggerType,
       event: meta.event ?? null,
       schedule: meta.schedule || null,
-      scheduleDescription: meta.schedule ? describeCron(meta.schedule) : null,
+      timezone: meta.timezone ? effectiveTimezone(meta.timezone) : null,
+      scheduleDescription: meta.schedule
+        ? describeCron(meta.schedule, effectiveTimezone(meta.timezone))
+        : null,
       condition: meta.condition ?? null,
       mode: meta.mode,
       domain: meta.domain ?? null,
@@ -127,6 +130,7 @@ async function handleDefine(
         triggerType: automationTriggerType(args.trigger_type),
         body: typeof args.body === "string" ? args.body : "",
         schedule: typeof args.schedule === "string" ? args.schedule : undefined,
+        timezone: typeof args.timezone === "string" ? args.timezone : undefined,
         event: typeof args.event === "string" ? args.event : undefined,
         condition:
           typeof args.condition === "string" ? args.condition : undefined,
@@ -164,6 +168,7 @@ async function handleDefine(
       triggerType: definition.meta.triggerType,
       event: definition.meta.event ?? null,
       schedule: definition.meta.schedule || null,
+      timezone: definition.meta.timezone ?? null,
       nextRun: definition.meta.nextRun ?? null,
       createdBy: definition.meta.createdBy,
       runAs: definition.meta.runAs,
@@ -208,6 +213,7 @@ async function handleUpdate(
               : null,
         body: typeof args.body === "string" ? args.body : undefined,
         schedule: typeof args.schedule === "string" ? args.schedule : undefined,
+        timezone: typeof args.timezone === "string" ? args.timezone : undefined,
         model:
           args.model === undefined
             ? undefined
@@ -225,6 +231,7 @@ async function handleUpdate(
       triggerType: definition.meta.triggerType,
       enabled: definition.meta.enabled,
       schedule: definition.meta.schedule || null,
+      timezone: definition.meta.timezone ?? null,
       nextRun: definition.meta.nextRun ?? null,
       createdBy: definition.meta.createdBy,
       runAs: definition.meta.runAs,
@@ -305,8 +312,8 @@ export function createAutomationToolEntries(
 
 - **list-events**: List all registered event types that automations can subscribe to. Returns event names, descriptions, and payload schemas. Call this BEFORE defining an automation to discover available events.
 - **list**: List all automations (triggers). Shows trigger, status, model, MCP allowlist, and delivery metadata. Optional params: scope, domain, enabled_only.
-- **define**: Create a new automation. IMPORTANT: Always confirm with the user before calling — show them a summary of what will be created. Required params: name, trigger_type, body. Optional: scope, event, schedule, condition, mode, domain, delegated_policy_id, model, mcpTools.
-- **update**: Update an existing automation's settings without changing its creator (enabled, schedule, condition, body, policy, model, MCP allowlist). Required param: name. Use the same scope it was created in.
+- **define**: Create a new automation. IMPORTANT: Always confirm with the user before calling — show them a summary of what will be created. Required params: name, trigger_type, body. Optional: scope, event, schedule, timezone, condition, mode, domain, delegated_policy_id, model, mcpTools.
+- **update**: Update an existing automation's settings without changing its creator (enabled, schedule, timezone, condition, body, policy, model, MCP allowlist). Required param: name. Use the same scope it was created in.
 - **delete**: Delete an automation. Always confirm with the user first. Required param: name.
 - **fire-test**: Fire a test event to validate automations. Emits a test.event.fired event. Optional param: data (JSON string).`,
         parameters: {
@@ -339,6 +346,11 @@ export function createAutomationToolEntries(
               description:
                 "For event triggers: the event name to subscribe to. Call with action=list-events first to see available events.",
             },
+            timezone: {
+              type: "string",
+              description:
+                "IANA timezone the cron clock time is read in, e.g. 'America/New_York'. Optional; defaults to the user's saved scheduling timezone, then the caller's browser zone. Always pass this when the user names a time of day.",
+            },
             schedule: {
               type: "string",
               description:

package/corpus/core/src/triggers/dispatcher.ts

@@ -82,6 +82,31 @@ const _eventSubscriptions = new Map<string, string>();
 const _dispatchingTriggers = new Set<string>();
 let _deps: TriggerDispatcherDeps | null = null;
 
+/**
+ * Record that a tick evaluated this trigger and declined to dispatch it.
+ * `lastRun` stays untouched — nothing ran — and an unchanged outcome is not
+ * re-persisted, so a permanently blocked trigger neither reports phantom runs
+ * nor rewrites its resource on every matching event.
+ */
+async function recordTriggerSkip(
+  resource: Resource,
+  meta: TriggerFrontmatter,
+  body: string,
+  status: "skipped" | "error",
+  reason: string | undefined,
+): Promise<void> {
+  const unchanged = meta.lastStatus === status && meta.lastError === reason;
+  meta.lastCheck = new Date().toISOString();
+  meta.lastStatus = status;
+  meta.lastError = reason;
+  if (unchanged) return;
+  await resourcePut(
+    resource.owner,
+    resource.path,
+    buildTriggerContent(meta, body),
+  );
+}
+
 /**
  * Initialize the trigger dispatcher. Call once at server startup.
  * Loads all event-triggered jobs and subscribes to their events.
@@ -173,25 +198,22 @@ async function handleEvent(
             meta,
           );
         } catch {
-          meta.lastRun = new Date().toISOString();
-          meta.lastStatus = "skipped";
-          meta.lastError =
-            "Could not verify the automation execution identity.";
-          await resourcePut(
-            resource.owner,
-            resource.path,
-            buildTriggerContent(meta, body),
+          await recordTriggerSkip(
+            resource,
+            meta,
+            body,
+            "skipped",
+            "Could not verify the automation execution identity.",
           );
           continue;
         }
         if (!resolved.ok) {
-          meta.lastRun = new Date().toISOString();
-          meta.lastStatus = "skipped";
-          meta.lastError = resolved.reason;
-          await resourcePut(
-            resource.owner,
-            resource.path,
-            buildTriggerContent(meta, body),
+          await recordTriggerSkip(
+            resource,
+            meta,
+            body,
+            "skipped",
+            resolved.reason,
           );
           continue;
         }
@@ -206,13 +228,12 @@ async function handleEvent(
       const userApiKey = await getOwnerActiveApiKey(owner);
       const apiKey = userApiKey || _deps.apiKey;
       if (!apiKey) {
-        meta.lastRun = new Date().toISOString();
-        meta.lastStatus = "error";
-        meta.lastError = "No API key is available for this automation";
-        await resourcePut(
-          resource.owner,
-          resource.path,
-          buildTriggerContent(meta, body),
+        await recordTriggerSkip(
+          resource,
+          meta,
+          body,
+          "error",
+          "No API key is available for this automation",
         );
         console.warn(`[triggers] ${meta.lastError}: "${resource.path}"`);
         continue;
@@ -221,14 +242,7 @@ async function handleEvent(
       // Evaluate condition
       const matches = await evaluateCondition(meta.condition, payload, apiKey);
       if (!matches) {
-        meta.lastRun = new Date().toISOString();
-        meta.lastStatus = "skipped";
-        meta.lastError = undefined;
-        await resourcePut(
-          resource.owner,
-          resource.path,
-          buildTriggerContent(meta, body),
-        );
+        await recordTriggerSkip(resource, meta, body, "skipped", undefined);
         continue;
       }