@vellumai/assistant 0.5.3 → 0.5.5

package/src/runtime/routes/guardian-bootstrap-routes.ts

@@ -28,6 +28,7 @@ type ServerWithRequestIP = {
   ): { address: string; family: string; port: number } | null;
 };
 import { isHttpAuthDisabled } from "../../config/env.js";
+import { getIsContainerized } from "../../config/env-registry.js";
 
 const log = getLogger("guardian-bootstrap");
 
@@ -86,19 +87,30 @@ export async function handleGuardianBootstrap(
   req: Request,
   server: ServerWithRequestIP,
 ): Promise<Response> {
+  // Reject non-private-network peers (allows loopback, Docker bridge, etc.)
+  const peerIp = server.requestIP(req)?.address;
+  if ((!peerIp || !isPrivateAddress(peerIp)) && !isHttpAuthDisabled()) {
+    return httpError("FORBIDDEN", "Bootstrap endpoint is local-only", 403);
+  }
+
   // Reject requests forwarded from public networks. The gateway sets
   // x-forwarded-for to the real client IP; if that IP is on a private
   // network (loopback, Docker bridge, RFC 1918) the request is still
   // considered local. Only reject when the forwarded IP is public.
+  //
+  // Skip this check when running in a container: the peer IP was already
+  // validated above (Docker bridge network = private), so the request
+  // reached us through a co-located gateway. The x-forwarded-for header
+  // reflects the original external client (e.g. platform proxy) and is
+  // not meaningful for local-only enforcement in this topology.
   const forwarded = req.headers.get("x-forwarded-for");
   const forwardedIp = forwarded ? forwarded.split(",")[0].trim() : null;
-  if (forwardedIp && !isPrivateAddress(forwardedIp) && !isHttpAuthDisabled()) {
-    return httpError("FORBIDDEN", "Bootstrap endpoint is local-only", 403);
-  }
-
-  // Reject non-private-network peers (allows loopback, Docker bridge, etc.)
-  const peerIp = server.requestIP(req)?.address;
-  if ((!peerIp || !isPrivateAddress(peerIp)) && !isHttpAuthDisabled()) {
+  if (
+    forwardedIp &&
+    !isPrivateAddress(forwardedIp) &&
+    !isHttpAuthDisabled() &&
+    !getIsContainerized()
+  ) {
     return httpError("FORBIDDEN", "Bootstrap endpoint is local-only", 403);
   }
 

package/src/runtime/routes/inbound-message-handler.ts

@@ -44,6 +44,7 @@ import { handleEditIntercept } from "./inbound-stages/edit-intercept.js";
 import { handleEscalationIntercept } from "./inbound-stages/escalation-intercept.js";
 import { handleGuardianReplyIntercept } from "./inbound-stages/guardian-reply-intercept.js";
 import { runSecretIngressCheck } from "./inbound-stages/secret-ingress-check.js";
+import { tryTranscribeAudioAttachments } from "./inbound-stages/transcribe-audio.js";
 import { handleVerificationIntercept } from "./inbound-stages/verification-intercept.js";
 
 const log = getLogger("runtime-http");
@@ -144,7 +145,7 @@ export async function handleChannelInbound(
     return httpError("BAD_REQUEST", "content must be a string", 400);
   }
 
-  const trimmedContent = typeof content === "string" ? content.trim() : "";
+  let trimmedContent = typeof content === "string" ? content.trim() : "";
   const hasAttachments =
     Array.isArray(attachmentIds) && attachmentIds.length > 0;
 
@@ -227,6 +228,29 @@ export async function handleChannelInbound(
     }
   }
 
+  // Auto-transcribe audio attachments from channel messages
+  if (hasAttachments && sourceChannel) {
+    const transcribeResult = await tryTranscribeAudioAttachments(attachmentIds);
+    switch (transcribeResult.status) {
+      case "transcribed":
+        // For voice-only messages (empty content), this becomes the message text.
+        // For audio+caption, both are preserved.
+        trimmedContent =
+          transcribeResult.text +
+          (trimmedContent ? `\n\n${trimmedContent}` : "");
+        break;
+      case "no_provider":
+      case "error":
+        // Inject a hint so the assistant knows the user sent audio and why
+        // transcription failed — it can then guide the user (e.g. set up API key).
+        trimmedContent =
+          `[Voice message received — ${transcribeResult.reason}]` +
+          (trimmedContent ? `\n\n${trimmedContent}` : "");
+        break;
+      // "no_audio", "disabled" — no action needed
+    }
+  }
+
   const sourceMessageId =
     typeof sourceMetadata?.messageId === "string"
       ? sourceMetadata.messageId
@@ -333,7 +357,7 @@ export async function handleChannelInbound(
     externalMessageId,
     conversationId: result.conversationId,
     eventId: result.eventId,
-    content,
+    content: trimmedContent,
     attachmentIds,
     sourceMetadata: body.sourceMetadata,
     actorDisplayName: body.actorDisplayName,
@@ -612,7 +636,7 @@ export async function handleChannelInbound(
       processMessage,
       conversationId: result.conversationId,
       eventId: result.eventId,
-      content: content ?? "",
+      content: trimmedContent,
       attachmentIds: hasAttachments ? attachmentIds : undefined,
       sourceChannel,
       sourceInterface,

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -79,14 +79,29 @@ export interface AclResult {
   guardianVerifyCode: string | undefined;
 }
 
+/**
+ * Strip Slack/Telegram mrkdwn formatting wrappers from a raw message.
+ * When users copy-paste a verification code from the desktop app with
+ * rich-text formatting (e.g. bold), Slack preserves it as `*code*` in
+ * the message text, which would otherwise fail the strict bare-code regex.
+ */
+function stripMrkdwnFormatting(text: string): string {
+  // Bold (*…*), italic (_…_), strikethrough (~…~), inline code (`…`)
+  return text.replace(/^[*_~`]+/, "").replace(/[*_~`]+$/, "");
+}
+
 /**
  * Parse a guardian verification code from message content.
  * Accepts a bare code as the entire message: 6-digit numeric OR 64-char hex
  * (hex is retained for compatibility with unbound inbound/bootstrap sessions
  * that intentionally use high-entropy secrets).
+ *
+ * Strips surrounding mrkdwn formatting characters first so that codes
+ * pasted with bold/italic/code formatting are still recognized.
  */
 function parseGuardianVerifyCode(content: string): string | undefined {
-  const bareMatch = content.match(/^([0-9a-fA-F]{64}|\d{6})$/);
+  const stripped = stripMrkdwnFormatting(content);
+  const bareMatch = stripped.match(/^([0-9a-fA-F]{64}|\d{6})$/);
   if (bareMatch) return bareMatch[1];
 
   return undefined;

package/src/runtime/routes/inbound-stages/transcribe-audio.test.ts

@@ -0,0 +1,287 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { SpeechToTextProvider } from "../../../providers/speech-to-text/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+let mockFeatureFlagEnabled = true;
+let mockAttachments: Array<{
+  id: string;
+  mimeType: string;
+  dataBase64: string;
+  originalFilename: string;
+  sizeBytes: number;
+  kind: string;
+  thumbnailBase64: string | null;
+  createdAt: number;
+}> = [];
+let mockProvider: SpeechToTextProvider | null = null;
+
+mock.module("../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => mockFeatureFlagEnabled,
+}));
+
+mock.module("../../../config/loader.js", () => ({
+  getConfig: () => ({ assistantFeatureFlagValues: {} }),
+}));
+
+mock.module("../../../memory/attachments-store.js", () => ({
+  getAttachmentsByIds: (ids: string[]) =>
+    mockAttachments.filter((a) => ids.includes(a.id)),
+  getAttachmentById: (id: string, _opts?: { hydrateFileData?: boolean }) =>
+    mockAttachments.find((a) => a.id === id) ?? null,
+}));
+
+mock.module("../../../providers/speech-to-text/resolve.js", () => ({
+  resolveSpeechToTextProvider: async () => mockProvider,
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+// Import after mocks are installed
+const { tryTranscribeAudioAttachments } = await import("./transcribe-audio.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeAudioAttachment(
+  id: string,
+  mimeType = "audio/ogg",
+  dataBase64 = Buffer.from("fake-audio-data").toString("base64"),
+) {
+  return {
+    id,
+    mimeType,
+    dataBase64,
+    originalFilename: `voice-${id}.ogg`,
+    sizeBytes: Buffer.from(dataBase64, "base64").length,
+    kind: "document" as const,
+    thumbnailBase64: null,
+    createdAt: Date.now(),
+  };
+}
+
+function makeDocumentAttachment(id: string) {
+  return {
+    id,
+    mimeType: "application/pdf",
+    dataBase64: Buffer.from("fake-pdf").toString("base64"),
+    originalFilename: `doc-${id}.pdf`,
+    sizeBytes: 8,
+    kind: "document" as const,
+    thumbnailBase64: null,
+    createdAt: Date.now(),
+  };
+}
+
+function makeImageAttachment(id: string) {
+  return {
+    id,
+    mimeType: "image/png",
+    dataBase64: Buffer.from("fake-image").toString("base64"),
+    originalFilename: `photo-${id}.png`,
+    sizeBytes: 10,
+    kind: "image" as const,
+    thumbnailBase64: null,
+    createdAt: Date.now(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("tryTranscribeAudioAttachments", () => {
+  beforeEach(() => {
+    mockFeatureFlagEnabled = true;
+    mockAttachments = [];
+    mockProvider = null;
+  });
+
+  afterEach(() => {
+    mockAttachments = [];
+  });
+
+  test("audio attachment is transcribed and returns transcribed result", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async () => ({ text: "Hello, how are you?" }),
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result).toEqual({
+      status: "transcribed",
+      text: "Hello, how are you?",
+    });
+  });
+
+  test("non-audio attachments return no_audio", async () => {
+    const doc = makeDocumentAttachment("d1");
+    const img = makeImageAttachment("i1");
+    mockAttachments = [doc, img];
+    mockProvider = {
+      transcribe: async () => ({ text: "should not be called" }),
+    };
+
+    const result = await tryTranscribeAudioAttachments(["d1", "i1"]);
+
+    expect(result).toEqual({ status: "no_audio" });
+  });
+
+  test("no API key returns no_provider with helpful reason string", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = null; // No provider resolved
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result.status).toBe("no_provider");
+    expect((result as { reason: string }).reason).toContain(
+      "No OpenAI API key configured",
+    );
+  });
+
+  test("API failure returns error with reason", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async () => {
+        throw new Error("API rate limit exceeded");
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result.status).toBe("error");
+    expect((result as { reason: string }).reason).toBe(
+      "API rate limit exceeded",
+    );
+  });
+
+  test("feature flag disabled returns disabled", async () => {
+    mockFeatureFlagEnabled = false;
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result).toEqual({ status: "disabled" });
+  });
+
+  test("30-second timeout fires and returns error without blocking", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async (_audio, _mime, signal) => {
+        // Simulate a provider that respects the abort signal
+        return new Promise((_resolve, reject) => {
+          if (signal?.aborted) {
+            reject(new DOMException("The operation was aborted", "AbortError"));
+            return;
+          }
+          const onAbort = () => {
+            reject(new DOMException("The operation was aborted", "AbortError"));
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+        });
+      },
+    };
+
+    // The timeout is 30s in the real code, but the test's mock provider
+    // aborts immediately when signaled. We verify the error path works
+    // by checking the result type. For a true timeout test we'd need
+    // to override the timeout constant, but this confirms the abort
+    // path produces the correct result.
+    // Instead, let's test with a provider that checks signal state:
+    mockProvider = {
+      transcribe: async () => {
+        throw new DOMException("The operation was aborted", "AbortError");
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result.status).toBe("error");
+    expect((result as { reason: string }).reason).toBe(
+      "Transcription timed out",
+    );
+  });
+
+  test("multiple audio attachments are transcribed and concatenated", async () => {
+    const a1 = makeAudioAttachment("a1");
+    const a2 = makeAudioAttachment("a2", "audio/mpeg");
+    mockAttachments = [a1, a2];
+
+    let callCount = 0;
+    mockProvider = {
+      transcribe: async () => {
+        callCount++;
+        return { text: callCount === 1 ? "First message" : "Second message" };
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1", "a2"]);
+
+    expect(result).toEqual({
+      status: "transcribed",
+      text: "First message\n\nSecond message",
+    });
+    expect(callCount).toBe(2);
+  });
+
+  test("mixed audio and non-audio attachments: only audio is transcribed", async () => {
+    const audio = makeAudioAttachment("a1");
+    const doc = makeDocumentAttachment("d1");
+    mockAttachments = [audio, doc];
+
+    let transcribeCallCount = 0;
+    mockProvider = {
+      transcribe: async () => {
+        transcribeCallCount++;
+        return { text: "Voice transcription" };
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1", "d1"]);
+
+    expect(result).toEqual({
+      status: "transcribed",
+      text: "Voice transcription",
+    });
+    expect(transcribeCallCount).toBe(1);
+  });
+
+  test("empty attachment IDs returns no_audio", async () => {
+    mockProvider = {
+      transcribe: async () => ({ text: "should not be called" }),
+    };
+
+    const result = await tryTranscribeAudioAttachments([]);
+
+    expect(result).toEqual({ status: "no_audio" });
+  });
+
+  test("attachment with empty transcription returns no_audio", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async () => ({ text: "   " }), // whitespace-only
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result).toEqual({ status: "no_audio" });
+  });
+});

package/src/runtime/routes/inbound-stages/transcribe-audio.ts

@@ -0,0 +1,122 @@
+/**
+ * Auto-transcribe audio attachments from channel inbound messages.
+ *
+ * Returns a discriminated result type so callers can handle each outcome
+ * (transcribed, no audio, disabled, no provider, error) without exceptions.
+ * Never throws — failures are represented as result variants so that message
+ * delivery is never blocked by transcription issues.
+ */
+
+import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
+import { getConfig } from "../../../config/loader.js";
+import * as attachmentsStore from "../../../memory/attachments-store.js";
+import { resolveSpeechToTextProvider } from "../../../providers/speech-to-text/resolve.js";
+import { getLogger } from "../../../util/logger.js";
+
+const log = getLogger("transcribe-audio");
+
+const VOICE_TRANSCRIPTION_FLAG_KEY =
+  "feature_flags.channel-voice-transcription.enabled" as const;
+
+/** Timeout for the entire transcription pipeline (all attachments). */
+const TRANSCRIPTION_TIMEOUT_MS = 30_000;
+
+// ---------------------------------------------------------------------------
+// Result type
+// ---------------------------------------------------------------------------
+
+export type TranscribeResult =
+  | { status: "transcribed"; text: string }
+  | { status: "no_audio" }
+  | { status: "disabled" }
+  | { status: "no_provider"; reason: string }
+  | { status: "error"; reason: string };
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export async function tryTranscribeAudioAttachments(
+  attachmentIds: string[],
+): Promise<TranscribeResult> {
+  try {
+    // Check feature flag
+    const config = getConfig();
+    if (!isAssistantFeatureFlagEnabled(VOICE_TRANSCRIPTION_FLAG_KEY, config)) {
+      return { status: "disabled" };
+    }
+
+    // Look up attachments and filter to audio MIME types
+    const resolved = attachmentsStore.getAttachmentsByIds(attachmentIds);
+    const audioAttachments = resolved.filter((a) =>
+      a.mimeType.startsWith("audio/"),
+    );
+
+    if (audioAttachments.length === 0) {
+      return { status: "no_audio" };
+    }
+
+    // Resolve STT provider
+    const provider = await resolveSpeechToTextProvider();
+    if (!provider) {
+      return {
+        status: "no_provider",
+        reason:
+          "No OpenAI API key configured. Set one up to enable voice message transcription.",
+      };
+    }
+
+    // Transcribe each audio attachment with a shared timeout
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(
+      () => abortController.abort(),
+      TRANSCRIPTION_TIMEOUT_MS,
+    );
+
+    try {
+      const transcriptions: string[] = [];
+
+      for (const attachment of audioAttachments) {
+        // Hydrate the base64 data for the attachment
+        const hydrated = attachmentsStore.getAttachmentById(attachment.id, {
+          hydrateFileData: true,
+        });
+        if (!hydrated || !hydrated.dataBase64) {
+          log.warn(
+            { attachmentId: attachment.id },
+            "Could not hydrate audio attachment data; skipping",
+          );
+          continue;
+        }
+
+        const buffer = Buffer.from(hydrated.dataBase64, "base64");
+        const result = await provider.transcribe(
+          buffer,
+          attachment.mimeType,
+          abortController.signal,
+        );
+
+        if (result.text.trim()) {
+          transcriptions.push(result.text.trim());
+        }
+      }
+
+      if (transcriptions.length === 0) {
+        return { status: "no_audio" };
+      }
+
+      return { status: "transcribed", text: transcriptions.join("\n\n") };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch (err: unknown) {
+    const reason =
+      err instanceof Error
+        ? err.name === "AbortError"
+          ? "Transcription timed out"
+          : err.message
+        : String(err);
+    log.warn({ err }, "Audio transcription failed");
+    return { status: "error", reason };
+  }
+}

package/src/runtime/routes/log-export-routes.ts

@@ -444,6 +444,7 @@ const WORKSPACE_SKIP_DIRS = new Set([
   "embedding-models",
   "data/qdrant",
   "data/attachments",
+  "data/sounds",
   "conversations",
 ]);
 

package/src/runtime/routes/secret-routes.ts

@@ -10,7 +10,7 @@ import {
   invalidateConfigCache,
 } from "../../config/loader.js";
 import type { CesClient } from "../../credential-execution/client.js";
-import { setSentryOrganizationId } from "../../instrument.js";
+import { setSentryOrganizationId, setSentryUserId } from "../../instrument.js";
 import { clearEmbeddingBackendCache } from "../../memory/embedding-backend.js";
 import { syncManualTokenConnection } from "../../oauth/manual-token-connection.js";
 import { validateAnthropicApiKey } from "../../providers/anthropic/client.js";
@@ -182,6 +182,7 @@ export async function handleAddSecret(
           500,
         );
       }
+      clearEmbeddingBackendCache();
       invalidateConfigCache();
       await initializeProviders(getConfig());
       log.info({ provider: name }, "API key updated via HTTP");
@@ -234,6 +235,7 @@ export async function handleAddSecret(
           setSentryOrganizationId(undefined);
         } else if (field === "platform_user_id") {
           setPlatformUserId(undefined);
+          setSentryUserId(undefined);
         }
         deleteCredentialMetadata(service, field);
       } else {
@@ -259,6 +261,7 @@ export async function handleAddSecret(
         }
         if (service === "vellum" && field === "platform_user_id") {
           setPlatformUserId(effectiveValue || undefined);
+          setSentryUserId(effectiveValue || undefined);
         }
       }
       if (isManagedProxyCredential(service, field)) {
@@ -394,6 +397,7 @@ export async function handleDeleteSecret(req: Request): Promise<Response> {
       }
       if (service === "vellum" && field === "platform_user_id") {
         setPlatformUserId(undefined);
+        setSentryUserId(undefined);
       }
       if (isManagedProxyCredential(service, field)) {
         await initializeProviders(getConfig());

package/src/schedule/schedule-store.ts

@@ -35,6 +35,7 @@ export interface ScheduleJob {
   mode: ScheduleMode;
   routingIntent: RoutingIntent;
   routingHints: Record<string, unknown>;
+  quiet: boolean;
   status: ScheduleStatus;
   createdAt: number;
   updatedAt: number;
@@ -91,6 +92,7 @@ export function createSchedule(params: {
   mode?: ScheduleMode;
   routingIntent?: RoutingIntent;
   routingHints?: Record<string, unknown>;
+  quiet?: boolean;
 }): ScheduleJob {
   const expression = params.expression ?? params.cronExpression ?? null;
   const isOneShot = expression == null;
@@ -118,6 +120,7 @@ export function createSchedule(params: {
   const mode = params.mode ?? "execute";
   const routingIntent = params.routingIntent ?? "all_channels";
   const routingHints = params.routingHints ?? {};
+  const quiet = params.quiet ?? false;
 
   let nextRunAt: number;
   if (isOneShot) {
@@ -144,6 +147,7 @@ export function createSchedule(params: {
     mode,
     routingIntent,
     routingHintsJson: JSON.stringify(routingHints),
+    quiet,
     status: "active" as ScheduleStatus,
     createdAt: now,
     updatedAt: now,
@@ -236,6 +240,7 @@ export function updateSchedule(
     mode?: ScheduleMode;
     routingIntent?: RoutingIntent;
     routingHints?: Record<string, unknown>;
+    quiet?: boolean;
   },
 ): ScheduleJob | null {
   const db = getDb();
@@ -290,6 +295,7 @@ export function updateSchedule(
     set.routingIntent = updates.routingIntent;
   if (updates.routingHints !== undefined)
     set.routingHintsJson = JSON.stringify(updates.routingHints);
+  if (updates.quiet !== undefined) set.quiet = updates.quiet;
 
   // Recompute nextRunAt if schedule timing may have changed (only for recurring)
   if (
@@ -771,6 +777,7 @@ function parseJobRow(row: typeof scheduleJobs.$inferSelect): ScheduleJob {
     mode: (row.mode ?? "execute") as ScheduleMode,
     routingIntent: (row.routingIntent ?? "all_channels") as RoutingIntent,
     routingHints: safeParseJson(row.routingHintsJson),
+    quiet: row.quiet ?? false,
     status: (row.status ?? "active") as ScheduleStatus,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,

package/src/schedule/scheduler.ts

@@ -206,7 +206,9 @@ async function runScheduleOnce(
           if (isOneShot) failOneShot(job.id);
         } else {
           completeScheduleRun(runId, { status: "ok" });
-          notifySchedule({ id: job.id, name: job.name });
+          if (!job.quiet) {
+            notifySchedule({ id: job.id, name: job.name });
+          }
           if (isOneShot) completeOneShot(job.id);
         }
         processed += 1;
@@ -278,7 +280,9 @@ async function runScheduleOnce(
         trustClass: "guardian",
       });
       completeScheduleRun(runId, { status: "ok" });
-      notifySchedule({ id: job.id, name: job.name });
+      if (!job.quiet) {
+        notifySchedule({ id: job.id, name: job.name });
+      }
       if (isOneShot) completeOneShot(job.id);
       processed += 1;
     } catch (err) {