@vellumai/assistant 0.8.0 → 0.8.1

package/src/schedule/scheduler.ts

@@ -3,18 +3,15 @@ import {
   diskPressureBackgroundSkipLogFields,
   shouldLogDiskPressureBackgroundSkip,
 } from "../daemon/disk-pressure-background-gate.js";
-import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getConversation } from "../memory/conversation-crud.js";
 import { invalidateAssistantInferredItemsForConversation } from "../memory/task-memory-cleanup.js";
+import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import { wakeAgentForOpportunity } from "../runtime/agent-wake.js";
+import { runBackgroundJob } from "../runtime/background-job-runner.js";
 import { runSequencesOnce } from "../sequence/engine.js";
 import { getLogger } from "../util/logger.js";
-import {
-  runWatchersOnce,
-  type WatcherEscalator,
-  type WatcherNotifier,
-} from "../watcher/engine.js";
+import { runWatchersOnce, type WatcherNotifier } from "../watcher/engine.js";
 import { hasSetConstructs } from "./recurrence-engine.js";
 import { applyRetryDecision, decideRetry } from "./retry-policy.js";
 import { runScript, type ScriptResult } from "./run-script.js";
@@ -63,6 +60,20 @@ const TICK_INTERVAL_MS = 15_000;
  */
 const WAKE_MAX_RETRIES = 20;
 
+/**
+ * Hard timeout for `talk`-mode scheduled jobs. Schedules can do
+ * non-trivial work (research, summarize the day, etc.), so the cap is
+ * generous; it exists primarily so a wedged turn cannot block the next
+ * scheduler tick indefinitely. Mirrors the heartbeat/filing budgets.
+ */
+const SCHEDULE_TALK_TIMEOUT_MS = 30 * 60 * 1000;
+
+/**
+ * Apply retry policy on schedule-execution failure. Retries are scheduled by
+ * `applyRetryDecision`; once retries are exhausted, the `emitAlert` callback
+ * fires an `activity.failed` notification so the user sees that a job
+ * permanently failed rather than just silently disappearing.
+ */
 function handleExecutionFailure(params: {
   job: ScheduleJob;
   errorMsg: string;
@@ -77,8 +88,13 @@ function handleExecutionFailure(params: {
     scheduleRetry,
     failOneShotPermanently,
     resetRetryCount,
-    emitAlert: (title, summary, dedupKey) =>
-      emitScheduleFeedEvent({ title, summary, dedupKey }),
+    emitAlert: (_title, _summary, dedupKey) =>
+      emitScheduleActivityFailed({
+        jobId: params.job.id,
+        jobName: params.job.name,
+        errorMessage: params.errorMsg,
+        dedupKey,
+      }),
     log,
   });
 }
@@ -87,7 +103,6 @@ export function startScheduler(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
   watcherNotifier?: WatcherNotifier,
-  watcherEscalator?: WatcherEscalator,
   onScheduleConversationCreated?: ScheduleConversationCreatedNotifier,
 ): SchedulerHandle {
   let stopped = false;
@@ -101,7 +116,6 @@ export function startScheduler(
         processMessage,
         notifyScheduleOneShot,
         watcherNotifier,
-        watcherEscalator,
         onScheduleConversationCreated,
       );
     } catch (err) {
@@ -123,7 +137,6 @@ export function startScheduler(
         processMessage,
         notifyScheduleOneShot,
         watcherNotifier,
-        watcherEscalator,
         onScheduleConversationCreated,
       );
     },
@@ -138,7 +151,6 @@ export async function runScheduleOnce(
   processMessage: ScheduleMessageProcessor,
   notifyScheduleOneShot: ScheduleNotifyModeNotifier,
   watcherNotifier?: WatcherNotifier,
-  watcherEscalator?: WatcherEscalator,
   onScheduleConversationCreated?: ScheduleConversationCreatedNotifier,
 ): Promise<number> {
   const now = Date.now();
@@ -181,21 +193,11 @@ export async function runScheduleOnce(
           const successRunId = createScheduleRun(job.id, `notify-ok:${job.id}`);
           completeScheduleRun(successRunId, { status: "ok" });
           completeOneShot(job.id);
-          emitScheduleFeedEvent({
-            title: job.name,
-            summary: "Reminder fired.",
-            dedupKey: `schedule-notify-oneshot:${job.id}`,
-          });
         } else {
           // Track recurring notify-mode success so lastStatus resets to ok
           // and retryCount clears after a transient failure.
           const runId = createScheduleRun(job.id, `notify-ok:${job.id}`);
           completeScheduleRun(runId, { status: "ok" });
-          emitScheduleFeedEvent({
-            title: job.name,
-            summary: "Scheduled notification fired.",
-            dedupKey: `schedule-run:${runId}`,
-          });
         }
       } catch (err) {
         log.warn(
@@ -234,13 +236,6 @@ export async function runScheduleOnce(
           error: result.stderr || undefined,
         });
         if (result.exitCode === 0) {
-          if (!job.quiet) {
-            emitScheduleFeedEvent({
-              title: job.name,
-              summary: "Script ran.",
-              dedupKey: `schedule-run:${runId}`,
-            });
-          }
           if (isOneShot) completeOneShot(job.id);
         } else {
           const errorMsg =
@@ -337,13 +332,6 @@ export async function runScheduleOnce(
           completeScheduleRun(successRunId, { status: "ok" });
           completeOneShot(job.id);
         }
-        if (!job.quiet) {
-          emitScheduleFeedEvent({
-            title: job.name,
-            summary: "Deferred wake fired.",
-            dedupKey: `schedule-wake:${job.id}`,
-          });
-        }
       } catch (err) {
         log.warn(
           { err, jobId: job.id, name: job.name, wakeConversationId, isOneShot },
@@ -412,24 +400,23 @@ export async function runScheduleOnce(
         // Track the schedule run using the task's conversation
         const runId = createScheduleRun(job.id, result.conversationId);
         if (result.status === "failed") {
+          const errorMessage = result.error ?? "Task run failed";
           completeScheduleRun(runId, {
             status: "error",
-            error: result.error ?? "Task run failed",
+            error: errorMessage,
+          });
+          emitTaskActivityFailed({
+            taskId,
+            conversationId: result.conversationId,
+            errorMessage,
           });
           handleExecutionFailure({
             job,
-            errorMsg: result.error ?? "Task run failed",
+            errorMsg: errorMessage,
             isOneShot,
           });
         } else {
           completeScheduleRun(runId, { status: "ok" });
-          if (!job.quiet) {
-            emitScheduleFeedEvent({
-              title: job.name,
-              summary: "Scheduled task ran.",
-              dedupKey: `schedule-run:${runId}`,
-            });
-          }
           if (isOneShot) completeOneShot(job.id);
         }
         processed += 1;
@@ -464,6 +451,11 @@ export async function runScheduleOnce(
         });
         const runId = createScheduleRun(job.id, fallbackConversation.id);
         completeScheduleRun(runId, { status: "error", error: message });
+        emitTaskActivityFailed({
+          taskId,
+          conversationId: fallbackConversation.id,
+          errorMessage: message,
+        });
         handleExecutionFailure({
           job,
           errorMsg: message,
@@ -474,71 +466,104 @@ export async function runScheduleOnce(
     }
 
     // Reuse the conversation from the last successful run when the flag is set
-    // and a prior conversation still exists; otherwise bootstrap a new one.
-    let conversationId: string | null = null;
-    let conversationReused = false;
+    // and a prior conversation still exists; otherwise route through the
+    // shared `runBackgroundJob` runner (which bootstraps fresh, applies the
+    // standard timeout, and emits `activity.failed` on any failure).
+    const isRruleSetMsg =
+      job.syntax === "rrule" &&
+      job.expression != null &&
+      hasSetConstructs(job.expression);
+
+    let reusedConversationId: string | null = null;
     if (job.reuseConversation && !isOneShot) {
       const lastId = getLastScheduleConversationId(job.id);
       if (lastId && getConversation(lastId)) {
-        conversationId = lastId;
-        conversationReused = true;
+        reusedConversationId = lastId;
       }
     }
-    if (!conversationId) {
-      const conversation = bootstrapConversation({
-        conversationType: "scheduled",
-        source: "schedule",
+
+    log.info(
+      {
+        jobId: job.id,
+        name: job.name,
+        syntax: job.syntax,
+        expression: job.expression,
+        isRruleSet: isRruleSetMsg,
+        isOneShot,
+        ...(reusedConversationId
+          ? { conversationId: reusedConversationId }
+          : {}),
+      },
+      isOneShot ? "Executing one-shot schedule" : "Executing schedule",
+    );
+
+    let conversationId: string;
+    let ok: boolean;
+    let errorMsg: string | undefined;
+    const conversationReused = reusedConversationId != null;
+
+    if (reusedConversationId) {
+      // Reuse path: keep using the injected `processMessage` callback so the
+      // existing conversation is continued in place. `runBackgroundJob`
+      // unconditionally bootstraps a new conversation and is therefore not a
+      // drop-in replacement for the reuse semantics.
+      conversationId = reusedConversationId;
+      onScheduleConversationCreated?.({
+        conversationId,
         scheduleJobId: job.id,
-        groupId: "system:scheduled",
+        title: job.name,
+      });
+      try {
+        await processMessage(conversationId, job.message, {
+          trustClass: "guardian",
+        });
+        ok = true;
+      } catch (err) {
+        ok = false;
+        errorMsg = err instanceof Error ? err.message : String(err);
+      }
+    } else {
+      // Fresh-bootstrap path: route through the shared runner so failures
+      // surface via `activity.failed` and we get the standard timeout +
+      // error-classification policy applied to every background producer.
+      // The runner fires `onConversationCreated` synchronously after bootstrap
+      // (before `processMessage` starts) so the macOS sidebar gets the new
+      // conversation immediately rather than after the up-to-30-min job ends.
+      const result = await runBackgroundJob({
+        jobName: `schedule:${job.id}`,
+        source: "schedule",
+        prompt: job.message,
+        trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+        callSite: "mainAgent",
+        timeoutMs: SCHEDULE_TALK_TIMEOUT_MS,
         origin: "schedule",
-        systemHint: isOneShot
-          ? `Reminder: ${job.name}`
-          : `Schedule: ${job.name}`,
+        groupId: "system:scheduled",
+        conversationType: "scheduled",
+        scheduleJobId: job.id,
+        suppressFailureNotifications: job.quiet === true,
+        onConversationCreated: (newConversationId) => {
+          onScheduleConversationCreated?.({
+            conversationId: newConversationId,
+            scheduleJobId: job.id,
+            title: job.name,
+          });
+        },
       });
-      conversationId = conversation.id;
+      conversationId = result.conversationId;
+      ok = result.ok;
+      errorMsg = result.error?.message;
     }
-    onScheduleConversationCreated?.({
-      conversationId,
-      scheduleJobId: job.id,
-      title: job.name,
-    });
+
     const runId = createScheduleRun(job.id, conversationId);
-    const isRruleSetMsg =
-      job.syntax === "rrule" &&
-      job.expression != null &&
-      hasSetConstructs(job.expression);
 
-    try {
-      log.info(
-        {
-          jobId: job.id,
-          name: job.name,
-          syntax: job.syntax,
-          expression: job.expression,
-          isRruleSet: isRruleSetMsg,
-          isOneShot,
-          conversationId,
-        },
-        isOneShot ? "Executing one-shot schedule" : "Executing schedule",
-      );
-      await processMessage(conversationId, job.message, {
-        trustClass: "guardian",
-      });
+    if (ok) {
       completeScheduleRun(runId, { status: "ok" });
-      if (!job.quiet) {
-        emitScheduleFeedEvent({
-          title: job.name,
-          summary: isOneShot ? "One-shot reminder ran." : "Scheduled job ran.",
-          dedupKey: `schedule-run:${runId}`,
-        });
-      }
       if (isOneShot) completeOneShot(job.id);
       processed += 1;
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+    } else {
       log.warn(
         {
-          err,
+          err: errorMsg,
           jobId: job.id,
           name: job.name,
           syntax: job.syntax,
@@ -550,8 +575,12 @@ export async function runScheduleOnce(
           ? "One-shot schedule execution failed"
           : "Schedule execution failed",
       );
-      completeScheduleRun(runId, { status: "error", error: message });
-      handleExecutionFailure({ job, errorMsg: message, isOneShot });
+      completeScheduleRun(runId, { status: "error", error: errorMsg });
+      handleExecutionFailure({
+        job,
+        errorMsg: errorMsg ?? "Schedule run failed",
+        isOneShot,
+      });
 
       // Only skip invalidation when the conversation was *actually* reused,
       // i.e. it contains prior successful context worth preserving. When
@@ -572,13 +601,9 @@ export async function runScheduleOnce(
   }
 
   // ── Watchers (event-driven polling) ────────────────────────────────
-  if (watcherNotifier && watcherEscalator) {
+  if (watcherNotifier) {
     try {
-      const watcherProcessed = await runWatchersOnce(
-        processMessage,
-        watcherNotifier,
-        watcherEscalator,
-      );
+      const watcherProcessed = await runWatchersOnce(watcherNotifier);
       processed += watcherProcessed;
     } catch (err) {
       log.error({ err }, "Watcher tick failed");
@@ -587,7 +612,7 @@ export async function runScheduleOnce(
 
   // ── Sequences (multi-step outreach) ──────────────────────────────
   try {
-    const sequenceProcessed = await runSequencesOnce(processMessage);
+    const sequenceProcessed = await runSequencesOnce();
     processed += sequenceProcessed;
   } catch (err) {
     log.error({ err }, "Sequence engine tick failed");
@@ -600,30 +625,82 @@ export async function runScheduleOnce(
 }
 
 /**
- * Fire-and-forget home-feed emit for a successful schedule run.
- *
- * Wraps {@link emitFeedEvent} with local error handling so a schema
- * failure or writer hiccup can never interrupt the scheduler tick
- * loop. The dedupKey is always derived from the schedule run id (or
- * the job id, for one-shot notify-mode which fires before a run
- * record is created) so each run lands as its own entry in the
- * activity log — the writer's per-source cap keeps total volume
- * bounded.
+ * Emit an `activity.failed` notification for a failed scheduled task run.
+ * Mirrors the shape `runBackgroundJob` produces for its own failures so the
+ * home feed and native notifications stay consistent regardless of which
+ * code path executed the work. Fire-and-forget — a notification failure
+ * must never break scheduler operation.
  */
-function emitScheduleFeedEvent(params: {
-  title: string;
-  summary: string;
+function emitTaskActivityFailed(args: {
+  taskId: string;
+  conversationId: string;
+  errorMessage: string;
+}): void {
+  const day = new Date().toISOString().slice(0, 10);
+  emitNotificationSignal({
+    sourceChannel: "scheduler",
+    sourceContextId: args.conversationId,
+    sourceEventName: "activity.failed",
+    dedupeKey: `activity-failed:task:${args.taskId}:${day}`,
+    contextPayload: {
+      jobName: `task:${args.taskId}`,
+      errorMessage: args.errorMessage,
+      errorKind: "exception",
+    },
+    attentionHints: {
+      requiresAction: false,
+      urgency: "medium",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+  }).catch((emitErr) => {
+    log.warn(
+      {
+        err: emitErr instanceof Error ? emitErr.message : String(emitErr),
+        taskId: args.taskId,
+        conversationId: args.conversationId,
+      },
+      "Failed to emit activity.failed notification for scheduled task",
+    );
+  });
+}
+
+/**
+ * Emit an `activity.failed` notification for a schedule whose retries have
+ * been exhausted. Distinct from `emitTaskActivityFailed` (which fires per
+ * failed task run) — this one fires once when the retry policy has given
+ * up, so the dedupeKey caller is the per-attempt key passed in by
+ * `applyRetryDecision` (already includes the job id and a timestamp).
+ */
+function emitScheduleActivityFailed(args: {
+  jobId: string;
+  jobName: string;
+  errorMessage: string;
   dedupKey: string;
 }): void {
-  void emitFeedEvent({
-    source: "assistant",
-    title: params.title,
-    summary: params.summary,
-    dedupKey: params.dedupKey,
-  }).catch((err) => {
+  emitNotificationSignal({
+    sourceChannel: "scheduler",
+    sourceContextId: args.jobId,
+    sourceEventName: "activity.failed",
+    dedupeKey: args.dedupKey,
+    contextPayload: {
+      jobName: `schedule:${args.jobName}`,
+      errorMessage: args.errorMessage,
+      errorKind: "exception",
+    },
+    attentionHints: {
+      requiresAction: false,
+      urgency: "medium",
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+  }).catch((emitErr) => {
     log.warn(
-      { err, dedupKey: params.dedupKey },
-      "Failed to emit schedule feed event",
+      {
+        err: emitErr instanceof Error ? emitErr.message : String(emitErr),
+        jobId: args.jobId,
+      },
+      "Failed to emit activity.failed notification for exhausted schedule",
     );
   });
 }

package/src/security/__tests__/provider-key-env-fallback.test.ts

@@ -40,18 +40,19 @@ const STORE_PATH = join(TEST_DIR, "keys.enc");
  * Regression test for the env-var fallback in `getProviderKeyAsync`.
  *
  * PR #27126 introduced `getLlmProviderEnvVar` which is LLM-scoped only.
- * After that PR, calls like `getProviderKeyAsync("brave")` and
- * `getProviderKeyAsync("perplexity")` stopped resolving the env var when
- * the secure store was empty, breaking web-search for users with
- * env-var-sourced Brave/Perplexity keys. The fix (this PR) routes the
- * fallback through `getAnyProviderEnvVar` which consults both the LLM
- * catalog and the search-provider map.
+ * After that PR, calls like `getProviderKeyAsync("brave")`,
+ * `getProviderKeyAsync("perplexity")`, and other search-provider keys stopped
+ * resolving the env var when the secure store was empty, breaking web-search
+ * for users with env-var-sourced search keys. The fix routes the fallback
+ * through `getAnyProviderEnvVar` which consults both the LLM catalog and the
+ * search-provider map.
  */
 describe("getProviderKeyAsync env-var fallback (regression #27126)", () => {
   const SAVED_ENV: Record<string, string | undefined> = {};
   const MANAGED_VARS = [
     "BRAVE_API_KEY",
     "PERPLEXITY_API_KEY",
+    "TAVILY_API_KEY",
     "ANTHROPIC_API_KEY",
     "OPENAI_API_KEY",
   ];
@@ -97,6 +98,11 @@ describe("getProviderKeyAsync env-var fallback (regression #27126)", () => {
     expect(await getProviderKeyAsync("perplexity")).toBe("pplx-env-test");
   });
 
+  test("returns TAVILY_API_KEY from process.env when secure store is empty", async () => {
+    process.env.TAVILY_API_KEY = "tavily-env-test";
+    expect(await getProviderKeyAsync("tavily")).toBe("tavily-env-test");
+  });
+
   test("returns ANTHROPIC_API_KEY from process.env when secure store is empty (LLM regression)", async () => {
     process.env.ANTHROPIC_API_KEY = "anthropic-env-test";
     expect(await getProviderKeyAsync("anthropic")).toBe("anthropic-env-test");

package/src/security/secret-patterns.ts

@@ -130,4 +130,7 @@ export const PREFIX_PATTERNS: SecretPrefixPattern[] = [
 
   // -- Perplexity --
   { label: "Perplexity API Key", regex: /pplx-[A-Za-z0-9]{40,}/ },
+
+  // -- Tavily --
+  { label: "Tavily API Key", regex: /tvly-[A-Za-z0-9]{20,}/ },
 ];

package/src/sequence/engine.ts

@@ -6,10 +6,8 @@
  * sends through the messaging layer.
  */
 
-import { emitFeedEvent } from "../home/emit-feed-event.js";
-import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getMessages } from "../memory/conversation-crud.js";
-import type { ScheduleMessageProcessor } from "../schedule/scheduler-types.js";
+import { runBackgroundJob } from "../runtime/background-job-runner.js";
 import { getLogger } from "../util/logger.js";
 import { recordEvent } from "./analytics.js";
 import { checkAllPreSend, recordSend } from "./guardrails.js";
@@ -28,14 +26,13 @@ const log = getLogger("sequence-engine");
 
 const BATCH_SIZE = 10;
 const ERROR_RETRY_DELAY_MS = 60_000;
+const STEP_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes per step
 
 /**
  * Process due sequence enrollments. Called by the scheduler on each tick.
  * Returns the number of enrollments processed.
  */
-export async function runSequencesOnce(
-  processMessage: ScheduleMessageProcessor,
-): Promise<number> {
+export async function runSequencesOnce(): Promise<number> {
   const now = Date.now();
   const claimed = claimDueEnrollments(now, BATCH_SIZE);
   if (claimed.length === 0) return 0;
@@ -43,7 +40,7 @@ export async function runSequencesOnce(
   let processed = 0;
   for (const enrollment of claimed) {
     try {
-      await processEnrollment(enrollment, processMessage);
+      await processEnrollment(enrollment);
       processed += 1;
     } catch (err) {
       log.error(
@@ -83,7 +80,6 @@ export async function runSequencesOnce(
 
 async function processEnrollment(
   enrollment: SequenceEnrollment,
-  processMessage: ScheduleMessageProcessor,
 ): Promise<void> {
   const sequence = getSequence(enrollment.sequenceId);
   if (!sequence) {
@@ -146,30 +142,54 @@ async function processEnrollment(
   // Build the prompt for the assistant to generate and send the email
   const prompt = buildStepPrompt(enrollment, sequence, step);
 
-  // Create a conversation for this step execution
-  const conversation = bootstrapConversation({
-    source: "sequence",
-    origin: "sequence",
-    systemHint: `Sequence: ${sequence.name} — Step ${step.index + 1}`,
-  });
-
   log.info(
     {
       enrollmentId: enrollment.id,
       sequenceId: sequence.id,
       step: step.index,
       contactEmail: enrollment.contactEmail,
-      conversationId: conversation.id,
     },
     "Processing sequence step",
   );
 
-  await processMessage(conversation.id, prompt);
+  const result = await runBackgroundJob({
+    jobName: "sequence-step",
+    source: "sequence",
+    prompt,
+    systemHint: `Sequence: ${sequence.name} — Step ${step.index + 1}`,
+    trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+    callSite: "mainAgent",
+    timeoutMs: STEP_TIMEOUT_MS,
+    origin: "sequence",
+  });
+
+  if (!result.ok) {
+    // Timeouts do not cancel the in-flight `processMessage`, so retrying
+    // could double-send. Exit the enrollment instead of rescheduling.
+    if (result.errorKind === "timeout") {
+      log.error(
+        {
+          enrollmentId: enrollment.id,
+          sequenceId: sequence.id,
+          step: step.index,
+        },
+        "Sequence step timed out — exiting enrollment to prevent duplicate outreach",
+      );
+      recordEvent(sequence.id, enrollment.id, "fail", step.index, {
+        reason: "step_timeout",
+      });
+      exitEnrollment(enrollment.id, "failed");
+      return;
+    }
+    throw (
+      result.error ?? new Error(`Background job failed: ${result.errorKind}`)
+    );
+  }
 
   // Try to extract the email thread ID from conversation tool results so
   // subsequent steps can reply in the same conversation.
   const extractedConversationId =
-    extractThreadIdFromConversation(conversation.id) ?? undefined;
+    extractThreadIdFromConversation(result.conversationId) ?? undefined;
   if (extractedConversationId) {
     log.info(
       { enrollmentId: enrollment.id, conversationId: extractedConversationId },
@@ -201,28 +221,6 @@ async function processEnrollment(
   recordSend(sequence.id);
   recordEvent(sequence.id, enrollment.id, "send", step.index);
 
-  // Fire-and-forget home-feed activity log entry. Each (enrollment,
-  // step) pair is a distinct real signal (an email actually went
-  // out), so the dedupKey embeds both — repeat emits for the same
-  // step are impossible because the enrollment advances after this
-  // line, but if they did occur they'd land on the same entry.
-  void emitFeedEvent({
-    source: "assistant",
-    title: sequence.name,
-    summary: `Sent step ${step.index + 1} of ${sequence.steps.length} to ${enrollment.contactEmail}.`,
-    dedupKey: `sequence-step:${enrollment.id}:${step.index}`,
-  }).catch((err) => {
-    log.warn(
-      {
-        err,
-        sequenceId: sequence.id,
-        enrollmentId: enrollment.id,
-        step: step.index,
-      },
-      "Failed to emit sequence step feed event",
-    );
-  });
-
   // Advance to the next step
   const nextStepIndex = enrollment.currentStep + 1;
   if (nextStepIndex >= sequence.steps.length) {